@sayue_ltr/fleq 1.50.0 → 1.51.0

package/dist/dmdata/ws-client.js

@@ -90,6 +90,8 @@ class WebSocketManager {
     /** 接続を開始する */
     async connect() {
         this.shouldRun = true;
+        // 既存の再接続タイマーと CONNECTING 中のソケットを中止してから新規接続する
+        this.cancelInflight();
         const seq = ++this.connectSeq;
         await this.doConnect(seq);
     }
@@ -123,13 +125,46 @@ class WebSocketManager {
             this.heartbeatTimer = null;
         }
     }
+    /** 再接続タイマーと CONNECTING 中のソケットを中止する */
+    cancelInflight() {
+        if (this.reconnectTimer) {
+            clearTimeout(this.reconnectTimer);
+            this.reconnectTimer = null;
+        }
+        // CONNECTING 中のソケットがあれば閉じて孤立を防止
+        if (this.ws && this.ws.readyState !== ws_1.default.OPEN) {
+            try {
+                this.ws.close();
+            }
+            catch {
+                // close() 自体の失敗は無視
+            }
+            this.ws = null;
+        }
+    }
+    /** close/error 共通の切断後処理 */
+    onDisconnect(reason) {
+        this.clearTimers();
+        this.ws = null;
+        this.previousSocketId = this.socketId;
+        this.socketId = null;
+        this.heartbeatDeadlineAt = null;
+        this.endpointSelector.recordDisconnected();
+        this.events.onDisconnected(reason);
+        this.scheduleReconnect();
+    }
     async doConnect(seq) {
         try {
+            // REST API 呼び出し前に世代チェック — 古い再接続タイマーやシャットダウン後の呼び出しを弾く
+            if (!this.shouldRun || seq !== this.connectSeq) {
+                log.debug("接続中断(pre-API): shouldRun=false または世代不一致");
+                return;
+            }
             log.info("Socket Start を実行中...");
             const startRes = await (0, rest_client_1.prepareAndStartSocket)(this.config, this.previousSocketId ?? undefined);
-            // close() が呼ばれていたら接続を中断
+            // REST API 完了後に再度世代チェック — API 呼び出し中に close() や新しい connect() が来た場合を検出
             if (!this.shouldRun || seq !== this.connectSeq) {
-                log.debug("接続中断: close() が呼ばれたため新しいソケットを作成しません");
+                log.debug("接続中断(post-API): close() または新しい connect() が呼ばれたため新しいソケットを作成しません");
                 return;
             }
             if (!startRes.websocket) {
@@ -137,6 +172,11 @@ class WebSocketManager {
             }
             const wsUrl = this.endpointSelector.resolveUrl(startRes.websocket.url);
             log.info(`WebSocket に接続中: ${wsUrl.replace(/ticket=.*/, "ticket=***")}`);
+            // WebSocket 作成前に最終チェック
+            if (!this.shouldRun || seq !== this.connectSeq) {
+                log.debug("接続中断(pre-WS): close() または新しい connect() が呼ばれたため WebSocket を作成しません");
+                return;
+            }
             const socket = new ws_1.default(wsUrl, ["dmdata.v2"]);
             this.ws = socket;
             socket.on("open", () => {
@@ -161,14 +201,7 @@ class WebSocketManager {
                     return;
                 const reasonStr = reason.toString() || `code=${code}`;
                 log.warn(`WebSocket 切断: ${reasonStr}`);
-                this.clearTimers();
-                this.ws = null;
-                this.previousSocketId = this.socketId;
-                this.socketId = null;
-                this.heartbeatDeadlineAt = null;
-                this.endpointSelector.recordDisconnected();
-                this.events.onDisconnected(reasonStr);
-                this.scheduleReconnect();
+                this.onDisconnect(reasonStr);
             });
             socket.on("error", (err) => {
                 log.error(`WebSocket エラー: ${err.message}`);
@@ -181,14 +214,7 @@ class WebSocketManager {
                 catch {
                     // close() 自体の失敗は無視
                 }
-                this.clearTimers();
-                this.ws = null;
-                this.previousSocketId = this.socketId;
-                this.socketId = null;
-                this.heartbeatDeadlineAt = null;
-                this.endpointSelector.recordDisconnected();
-                this.events.onDisconnected(`error: ${err.message}`);
-                this.scheduleReconnect();
+                this.onDisconnect(`error: ${err.message}`);
             });
         }
         catch (err) {
@@ -329,6 +355,11 @@ class WebSocketManager {
         const currentSeq = this.connectSeq;
         this.reconnectTimer = setTimeout(async () => {
             this.reconnectTimer = null;
+            // タイマー発火時に世代が変わっていたら（手動 retry や close() があった）何もしない
+            if (!this.shouldRun || currentSeq !== this.connectSeq) {
+                log.debug("再接続タイマー発火をスキップ: shouldRun=false または世代不一致");
+                return;
+            }
             await this.doConnect(currentSeq);
         }, delay);
     }

package/dist/engine/cli/cli-run.js

@@ -39,6 +39,8 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.runMonitor = runMonitor;
 exports.resetTerminalTitle = resetTerminalTitle;
 const chalk_1 = __importDefault(require("chalk"));
+const fs = __importStar(require("fs"));
+const os = __importStar(require("os"));
 const rest_client_1 = require("../../dmdata/rest-client");
 const monitor_1 = require("../monitor/monitor");
 const formatter_1 = require("../../ui/formatter");
@@ -46,6 +48,7 @@ const theme_1 = require("../../ui/theme");
 const config_resolver_1 = require("../startup/config-resolver");
 const updateChecker = __importStar(require("../startup/update-checker"));
 const log = __importStar(require("../../logger"));
+const pipeline_controller_1 = require("../filter-template/pipeline-controller");
 // eslint-disable-next-line @typescript-eslint/no-var-requires
 const { version: VERSION } = require("../../../package.json");
 async function runMonitor(opts) {
@@ -84,6 +87,11 @@ async function runMonitor(opts) {
     for (const w of themeWarnings) {
         log.warn(w);
     }
+    // ナイトモード (resolveConfig で解決済み: CLI --night > Config > デフォルト)
+    if (config.nightMode) {
+        (0, theme_1.setNightMode)(true);
+        log.info("ナイトモード: ON");
+    }
     // formatter キャッシュ初期化
     if (config.tableWidth != null) {
         (0, formatter_1.setFrameWidth)(config.tableWidth);
@@ -92,9 +100,71 @@ async function runMonitor(opts) {
     (0, formatter_1.setDisplayMode)(config.displayMode);
     (0, formatter_1.setMaxObservations)(config.maxObservations);
     (0, formatter_1.setTruncation)(config.truncation);
+    // Filter / Template コンパイル
+    const pipelineController = new pipeline_controller_1.PipelineController();
+    if (opts.filter && opts.filter.length > 0) {
+        try {
+            // 複数フィルタは括弧付きで AND 結合
+            const combined = opts.filter.map((e) => `(${e})`).join(" and ");
+            pipelineController.setFilter(combined);
+            log.info(`フィルタ: ${opts.filter.join(" AND ")}`);
+        }
+        catch (err) {
+            if (err instanceof Error) {
+                log.error(`フィルタのコンパイルに失敗しました:\n${err.message}`);
+            }
+            process.exit(1);
+        }
+    }
+    if (opts.template) {
+        try {
+            let tplSource = opts.template;
+            if (tplSource.startsWith("@")) {
+                const filePath = tplSource.slice(1).replace(/^~/, os.homedir());
+                const MAX_TEMPLATE_SIZE = 1024 * 1024; // 1MB
+                const stat = fs.statSync(filePath);
+                if (stat.size > MAX_TEMPLATE_SIZE) {
+                    log.error(`テンプレートファイルが大きすぎます (${stat.size} bytes, 上限 ${MAX_TEMPLATE_SIZE} bytes): ${filePath}`);
+                    process.exit(1);
+                }
+                tplSource = fs.readFileSync(filePath, "utf-8").trim();
+            }
+            pipelineController.setTemplate(tplSource);
+            log.info("テンプレート: カスタム");
+        }
+        catch (err) {
+            if (err instanceof Error) {
+                log.warn(`テンプレートのコンパイルに失敗しました:\n${err.message}`);
+            }
+            // template エラーは警告のみ — 通常表示にフォールバック
+        }
+    }
+    if (opts.focus) {
+        try {
+            pipelineController.setFocus(opts.focus);
+            log.info(`フォーカス: ${opts.focus}`);
+        }
+        catch (err) {
+            if (err instanceof Error) {
+                log.error(`フォーカスのコンパイルに失敗しました:\n${err.message}`);
+            }
+            process.exit(1);
+        }
+    }
+    // summaryInterval (CLI > Config > デフォルト, 0 = 無効化)
+    if (opts.summaryInterval != null) {
+        if (opts.summaryInterval === 0) {
+            config.summaryInterval = null;
+            log.info("定期要約: 無効");
+        }
+        else {
+            config.summaryInterval = opts.summaryInterval;
+            log.info(`定期要約: ${opts.summaryInterval}分間隔`);
+        }
+    }
     printBanner(config);
     updateChecker.checkForUpdates("fleq", VERSION);
-    await (0, monitor_1.startMonitor)(config);
+    await (0, monitor_1.startMonitor)(config, pipelineController);
 }
 /** ターミナルタイトルを設定する (ANSI OSC sequence) */
 function setTerminalTitle(title) {

package/dist/engine/cli/cli.js

@@ -51,6 +51,18 @@ function buildProgram() {
         .option("--keep-existing", "既存のWebSocket接続を維持します（互換オプション。現在はこちらがデフォルトです）")
         .option("--close-others", "同一APIキーの既存 open socket を閉じてから接続します")
         .option("--mode <mode>", '表示モードを指定します: "normal" | "compact"')
+        .option("--filter <expr>", "条件式で電文を絞り込みます (複数指定で AND 結合)", (val, prev) => [...prev, val], [])
+        .option("--template <template>", "電文の1行要約テンプレートを指定します (@ でファイル読込)")
+        .option("--focus <expr>", "条件に一致しない電文を dim 表示に落とします")
+        .option("--summary-interval [minutes]", "N分ごとに受信要約を表示 (デフォルト10分, 0で無効化)", (val) => {
+        if (val === undefined || val === "true")
+            return 10;
+        const n = parseInt(val, 10);
+        if (n === 0)
+            return 0;
+        return Number.isFinite(n) && n > 0 ? n : 10;
+    })
+        .option("--night", "ナイトモードを有効にします")
         .option("--debug", "デバッグログを表示します", false)
         .action(async (opts) => {
         const { runMonitor } = await Promise.resolve().then(() => __importStar(require("./cli-run")));

package/dist/engine/filter/compile-filter.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.compileFilter = compileFilter;
+const tokenizer_1 = require("./tokenizer");
+const parser_1 = require("./parser");
+const type_checker_1 = require("./type-checker");
+const compiler_1 = require("./compiler");
+/**
+ * フィルタ式文字列を受け取り、tokenize → parse → typeCheck → compile の
+ * パイプラインを通して FilterPredicate を返す公開 API。
+ *
+ * @throws FilterSyntaxError — 構文エラー
+ * @throws FilterFieldError  — 未知フィールド
+ * @throws FilterTypeError   — 型不整合
+ */
+function compileFilter(expr) {
+    const tokens = (0, tokenizer_1.tokenize)(expr);
+    const ast = (0, parser_1.parse)(tokens, expr);
+    (0, type_checker_1.typeCheck)(ast, expr);
+    return (0, compiler_1.compile)(ast);
+}

package/dist/engine/filter/compiler.js

@@ -0,0 +1,188 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.compile = compile;
+const field_registry_1 = require("./field-registry");
+const rank_maps_1 = require("./rank-maps");
+function compile(ast) {
+    switch (ast.kind) {
+        case "or":
+            return compileOr(ast.children.map(compile));
+        case "and":
+            return compileAnd(ast.children.map(compile));
+        case "not":
+            return compileNot(compile(ast.operand));
+        case "truthy":
+            return compileTruthy(ast.value);
+        case "comparison":
+            return compileComparison(ast.left, ast.op, ast.right);
+    }
+}
+function compileOr(predicates) {
+    return (event) => predicates.some((p) => p(event));
+}
+function compileAnd(predicates) {
+    return (event) => predicates.every((p) => p(event));
+}
+function compileNot(predicate) {
+    return (event) => !predicate(event);
+}
+function compileTruthy(node) {
+    const getter = makeGetter(node);
+    return (event) => {
+        const val = getter(event);
+        return val != null && val !== false && val !== "" && val !== 0;
+    };
+}
+function compileComparison(left, op, right) {
+    const getLeft = makeGetter(left);
+    const getRight = makeGetter(right);
+    // フィールドの型情報を取得 (enum ランク変換用)
+    const leftField = left.kind === "path" ? (0, field_registry_1.resolveField)(left.segments.join(".")) : null;
+    const rankFn = leftField ? getRankFn(leftField.kind) : null;
+    switch (op) {
+        case "=":
+            return (event) => {
+                const l = getLeft(event);
+                const r = getRight(event);
+                if (l == null || r == null)
+                    return false;
+                return l === r;
+            };
+        case "!=":
+            return (event) => {
+                const l = getLeft(event);
+                const r = getRight(event);
+                if (l == null || r == null)
+                    return false;
+                return l !== r;
+            };
+        case "<":
+        case "<=":
+        case ">":
+        case ">=":
+            return (event) => {
+                let l = getLeft(event);
+                let r = getRight(event);
+                if (l == null || r == null)
+                    return false;
+                if (rankFn != null) {
+                    l = rankFn(String(l));
+                    r = rankFn(String(r));
+                    if (l == null || r == null)
+                        return false;
+                }
+                return compareOrdered(l, op, r);
+            };
+        case "~": {
+            // 右辺が文字列リテラルならコンパイル時に RegExp をキャッシュ
+            const cachedRegex = right.kind === "string" ? new RegExp(right.value) : null;
+            return (event) => {
+                const l = getLeft(event);
+                if (l == null)
+                    return false;
+                const re = cachedRegex ?? (() => {
+                    const r = getRight(event);
+                    if (r == null)
+                        return null;
+                    try {
+                        return new RegExp(String(r));
+                    }
+                    catch {
+                        return null;
+                    }
+                })();
+                if (re == null)
+                    return false;
+                return re.test(String(l));
+            };
+        }
+        case "!~": {
+            const cachedRegexNeg = right.kind === "string" ? new RegExp(right.value) : null;
+            return (event) => {
+                const l = getLeft(event);
+                if (l == null)
+                    return false;
+                const re = cachedRegexNeg ?? (() => {
+                    const r = getRight(event);
+                    if (r == null)
+                        return null;
+                    try {
+                        return new RegExp(String(r));
+                    }
+                    catch {
+                        return null;
+                    }
+                })();
+                if (re == null)
+                    return false;
+                return !re.test(String(l));
+            };
+        }
+        case "in":
+            return (event) => {
+                const l = getLeft(event);
+                const r = getRight(event);
+                if (l == null || r == null)
+                    return false;
+                if (Array.isArray(r))
+                    return r.includes(l);
+                return false;
+            };
+        case "contains":
+            return (event) => {
+                const l = getLeft(event);
+                const r = getRight(event);
+                if (l == null || r == null)
+                    return false;
+                if (Array.isArray(l))
+                    return l.includes(r);
+                if (typeof l === "string" && typeof r === "string")
+                    return l.includes(r);
+                return false;
+            };
+    }
+}
+function makeGetter(node) {
+    switch (node.kind) {
+        case "path": {
+            const field = (0, field_registry_1.resolveField)(node.segments.join("."));
+            if (field == null)
+                return () => null;
+            return (event) => field.get(event);
+        }
+        case "string":
+            return () => node.value;
+        case "number":
+            return () => node.value;
+        case "boolean":
+            return () => node.value;
+        case "null":
+            return () => null;
+        case "list":
+            return () => node.items.map((item) => {
+                switch (item.kind) {
+                    case "string": return item.value;
+                    case "number": return item.value;
+                    case "boolean": return item.value;
+                    default: return null;
+                }
+            });
+    }
+}
+function compareOrdered(l, op, r) {
+    switch (op) {
+        case "<": return l < r;
+        case "<=": return l <= r;
+        case ">": return l > r;
+        case ">=": return l >= r;
+        default: return false;
+    }
+}
+function getRankFn(kind) {
+    switch (kind) {
+        case "enum:frameLevel": return rank_maps_1.toFrameLevelRank;
+        case "enum:intensity": return rank_maps_1.toIntensityRank;
+        case "enum:lgInt": return rank_maps_1.toLgIntRank;
+        default: return null;
+    }
+}

package/dist/engine/filter/errors.js

@@ -0,0 +1,41 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FilterFieldError = exports.FilterTypeError = exports.FilterSyntaxError = void 0;
+class FilterSyntaxError extends Error {
+    source;
+    position;
+    constructor(source, position, message) {
+        super(message);
+        this.source = source;
+        this.position = position;
+        this.name = "FilterSyntaxError";
+    }
+    /** 位置付きフォーマット済みエラー表示 */
+    format() {
+        const pointer = " ".repeat(this.position) + "^";
+        return `フィルタ構文エラー: ${this.position + 1}文字目${this.message}\n${this.source}\n${pointer}`;
+    }
+}
+exports.FilterSyntaxError = FilterSyntaxError;
+class FilterTypeError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = "FilterTypeError";
+    }
+}
+exports.FilterTypeError = FilterTypeError;
+class FilterFieldError extends Error {
+    fieldName;
+    availableFields;
+    constructor(fieldName, availableFields) {
+        super(`未知のフィールド: ${fieldName}`);
+        this.fieldName = fieldName;
+        this.availableFields = availableFields;
+        this.name = "FilterFieldError";
+    }
+    format() {
+        const examples = this.availableFields.slice(0, 6).join(", ");
+        return `未知のフィールド: ${this.fieldName}\n使える例: ${examples}`;
+    }
+}
+exports.FilterFieldError = FilterFieldError;

package/dist/engine/filter/field-registry.js

@@ -0,0 +1,78 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FILTER_FIELDS = void 0;
+exports.resolveField = resolveField;
+exports.fieldNames = fieldNames;
+function field(kind, aliases, get, supportsOrder) {
+    return { kind, aliases, get, supportsOrder };
+}
+/** depth 文字列 "10km" → 数値 10 */
+function parseDepth(d) {
+    if (d == null)
+        return null;
+    const m = d.match(/^(\d+)/);
+    return m ? Number(m[1]) : null;
+}
+/** magnitude 文字列 → 数値 */
+function parseMagnitude(m) {
+    if (m == null)
+        return null;
+    const n = Number(m);
+    return Number.isFinite(n) ? n : null;
+}
+exports.FILTER_FIELDS = {
+    // 識別
+    domain: field("string", [], (e) => e.domain),
+    type: field("string", ["headType"], (e) => e.type),
+    subType: field("string", [], (e) => e.subType),
+    classification: field("string", [], (e) => e.classification),
+    id: field("string", [], (e) => e.id),
+    infoType: field("string", [], (e) => e.infoType),
+    // レベル
+    frameLevel: field("enum:frameLevel", ["level"], (e) => e.frameLevel, true),
+    // 状態フラグ
+    isCancellation: field("boolean", ["isCancelled"], (e) => e.isCancellation),
+    isWarning: field("boolean", [], (e) => e.isWarning),
+    isFinal: field("boolean", [], (e) => e.isFinal),
+    isTest: field("boolean", [], (e) => e.isTest),
+    isRenotification: field("boolean", [], (e) => e.isRenotification),
+    // イベント追跡
+    eventId: field("string", [], (e) => e.eventId),
+    serial: field("string", [], (e) => e.serial),
+    volcanoCode: field("string", [], (e) => e.volcanoCode),
+    volcanoName: field("string", [], (e) => e.volcanoName),
+    // 震源情報
+    hypocenterName: field("string", ["hypocenter"], (e) => e.hypocenterName),
+    depth: field("number", [], (e) => parseDepth(e.depth), true),
+    magnitude: field("number", ["mag"], (e) => parseMagnitude(e.magnitude), true),
+    // 強度
+    maxInt: field("enum:intensity", [], (e) => e.maxInt, true),
+    maxLgInt: field("enum:lgInt", [], (e) => e.maxLgInt, true),
+    forecastMaxInt: field("enum:intensity", [], (e) => e.forecastMaxInt, true),
+    alertLevel: field("number", [], (e) => e.alertLevel, true),
+    // テキスト
+    title: field("string", [], (e) => e.title),
+    headline: field("string", [], (e) => e.headline),
+    // 地域集約
+    areaNames: field("string[]", [], (e) => e.areaNames),
+    forecastAreaNames: field("string[]", [], (e) => e.forecastAreaNames),
+    municipalityNames: field("string[]", [], (e) => e.municipalityNames),
+    observationNames: field("string[]", [], (e) => e.observationNames),
+    areaCount: field("number", [], (e) => e.areaCount),
+    // 津波
+    tsunamiKinds: field("string[]", [], (e) => e.tsunamiKinds),
+};
+/** フィールド名 or エイリアスから FilterField を解決する */
+function resolveField(name) {
+    if (name in exports.FILTER_FIELDS)
+        return exports.FILTER_FIELDS[name];
+    for (const [, f] of Object.entries(exports.FILTER_FIELDS)) {
+        if (f.aliases.includes(name))
+            return f;
+    }
+    return null;
+}
+/** 公開フィールド名一覧 (エラーメッセージ用) */
+function fieldNames() {
+    return Object.keys(exports.FILTER_FIELDS);
+}

package/dist/engine/filter/index.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.fieldNames = exports.resolveField = exports.FilterFieldError = exports.FilterTypeError = exports.FilterSyntaxError = exports.compileFilter = void 0;
+// 公開 API
+var compile_filter_1 = require("./compile-filter");
+Object.defineProperty(exports, "compileFilter", { enumerable: true, get: function () { return compile_filter_1.compileFilter; } });
+// エラー
+var errors_1 = require("./errors");
+Object.defineProperty(exports, "FilterSyntaxError", { enumerable: true, get: function () { return errors_1.FilterSyntaxError; } });
+Object.defineProperty(exports, "FilterTypeError", { enumerable: true, get: function () { return errors_1.FilterTypeError; } });
+Object.defineProperty(exports, "FilterFieldError", { enumerable: true, get: function () { return errors_1.FilterFieldError; } });
+// フィールドユーティリティ
+var field_registry_1 = require("./field-registry");
+Object.defineProperty(exports, "resolveField", { enumerable: true, get: function () { return field_registry_1.resolveField; } });
+Object.defineProperty(exports, "fieldNames", { enumerable: true, get: function () { return field_registry_1.fieldNames; } });