@sayue_ltr/fleq 1.49.2

package/dist/dmdata/endpoint-selector.js

@@ -0,0 +1,185 @@
+"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 __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EndpointSelector = void 0;
+const log = __importStar(require("../logger"));
+/** リージョン別エンドポイント (冗長化用) */
+const REGION_HOSTS = {
+    tokyo: "ws-tokyo.api.dmdata.jp",
+    osaka: "ws-osaka.api.dmdata.jp",
+};
+/** 個別サーバー → リージョンのマッピング */
+const SERVER_TO_REGION = {
+    "ws001.api.dmdata.jp": "tokyo",
+    "ws002.api.dmdata.jp": "tokyo",
+    "ws003.api.dmdata.jp": "osaka",
+    "ws004.api.dmdata.jp": "osaka",
+    "ws-tokyo.api.dmdata.jp": "tokyo",
+    "ws-osaka.api.dmdata.jp": "osaka",
+};
+/** クールダウン初期値 (ミリ秒) */
+const INITIAL_COOLDOWN_MS = 120_000;
+/** クールダウン上限 (ミリ秒) */
+const MAX_COOLDOWN_MS = 900_000;
+/** 連続失敗判定の時間窓 (ミリ秒): この時間内に再度失敗するとクールダウンを延長 */
+const REPEATED_FAILURE_WINDOW_MS = 600_000;
+/**
+ * WebSocket エンドポイント選択器
+ *
+ * 切断時に失敗ホストを記録し、再接続時に別リージョンを優先する。
+ * Socket Start レスポンスの URL ホスト名を必要に応じて差し替える。
+ */
+class EndpointSelector {
+    /** ホストごとの失敗記録 */
+    failures = new Map();
+    /** 直前に接続していたホスト名 */
+    lastConnectedHost = null;
+    /**
+     * 接続成功時に呼ぶ。接続先ホストを記録する。
+     */
+    recordConnected(wsUrl) {
+        const host = this.extractHost(wsUrl);
+        if (host == null)
+            return;
+        this.lastConnectedHost = host;
+        log.debug(`EndpointSelector: 接続先を記録: ${host}`);
+    }
+    /**
+     * 切断時に呼ぶ。失敗ホストを記録しクールダウンを設定する。
+     */
+    recordDisconnected() {
+        const host = this.lastConnectedHost;
+        if (host == null)
+            return;
+        const now = Date.now();
+        const existing = this.failures.get(host);
+        let cooldownMs;
+        if (existing != null &&
+            now - existing.failedAt < REPEATED_FAILURE_WINDOW_MS) {
+            // 時間窓内の再失敗 → クールダウンを延長 (上限あり)
+            cooldownMs = Math.min(existing.cooldownMs * 2.5, MAX_COOLDOWN_MS);
+        }
+        else {
+            cooldownMs = INITIAL_COOLDOWN_MS;
+        }
+        this.failures.set(host, { failedAt: now, cooldownMs });
+        log.info(`EndpointSelector: ${host} を ${(cooldownMs / 1000).toFixed(0)}秒間クールダウン`);
+    }
+    /**
+     * Socket Start レスポンスの URL を受け取り、必要に応じてホスト名を差し替える。
+     *
+     * - 返却ホストがクールダウン中 → 反対リージョンに差し替え
+     * - 返却ホストが直前の失敗ホストと同じ → 反対リージョンに差し替え
+     * - それ以外 → そのまま返す
+     */
+    resolveUrl(originalUrl) {
+        this.pruneExpiredFailures();
+        const host = this.extractHost(originalUrl);
+        if (host == null)
+            return originalUrl;
+        const shouldAvoid = this.isInCooldown(host) || host === this.lastConnectedHost;
+        if (!shouldAvoid) {
+            log.debug(`EndpointSelector: ${host} をそのまま使用`);
+            return originalUrl;
+        }
+        // 反対リージョンを探す
+        const alternativeHost = this.findAlternativeHost(host);
+        if (alternativeHost == null) {
+            log.debug(`EndpointSelector: 代替ホストが見つからないため ${host} をそのまま使用`);
+            return originalUrl;
+        }
+        log.info(`EndpointSelector: ${host} を回避 → ${alternativeHost} に差し替え`);
+        return this.replaceHost(originalUrl, alternativeHost);
+    }
+    /** 指定ホストがクールダウン中かどうか */
+    isInCooldown(host) {
+        const record = this.failures.get(host);
+        if (record == null)
+            return false;
+        return Date.now() - record.failedAt < record.cooldownMs;
+    }
+    /** 期限切れの失敗記録を削除 */
+    pruneExpiredFailures() {
+        const now = Date.now();
+        for (const [host, record] of this.failures) {
+            if (now - record.failedAt >= record.cooldownMs) {
+                this.failures.delete(host);
+            }
+        }
+    }
+    /** 指定ホストの反対リージョンのエンドポイントを返す */
+    findAlternativeHost(currentHost) {
+        const currentRegion = this.detectRegion(currentHost);
+        // 反対リージョンを試す
+        const oppositeRegion = currentRegion === "tokyo" ? "osaka" : "tokyo";
+        const candidate = REGION_HOSTS[oppositeRegion];
+        // 反対リージョンもクールダウン中なら諦める
+        if (this.isInCooldown(candidate)) {
+            log.debug(`EndpointSelector: 反対リージョン ${candidate} もクールダウン中`);
+            return null;
+        }
+        return candidate;
+    }
+    /** ホスト名からリージョンを推定する */
+    detectRegion(host) {
+        const mapped = SERVER_TO_REGION[host];
+        if (mapped != null)
+            return mapped;
+        // ws.api.dmdata.jp や未知のホストはデフォルトで tokyo とみなす
+        return "tokyo";
+    }
+    /** URL からホスト名を抽出する */
+    extractHost(wsUrl) {
+        try {
+            const u = new URL(wsUrl);
+            return u.hostname;
+        }
+        catch {
+            return null;
+        }
+    }
+    /** URL のホスト名を差し替える */
+    replaceHost(originalUrl, newHost) {
+        try {
+            const u = new URL(originalUrl);
+            u.hostname = newHost;
+            return u.toString();
+        }
+        catch {
+            return originalUrl;
+        }
+    }
+}
+exports.EndpointSelector = EndpointSelector;

package/dist/dmdata/multi-connection-manager.js

@@ -0,0 +1,158 @@
+"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 __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MultiConnectionManager = void 0;
+const ws_client_1 = require("./ws-client");
+const log = __importStar(require("../logger"));
+/** 重複排除の最大キープ数 */
+const SEEN_IDS_MAX = 500;
+/** EEW 関連の分類区分 */
+const EEW_CLASSIFICATIONS = ["eew.forecast", "eew.warning"];
+/**
+ * 複線接続管理。primary (通常回線) に加え、backup (EEW 副回線) を動的に起動/停止できる。
+ * backup からの受信は msg.id で重複排除した上で、同じ onData イベントに委譲する。
+ */
+class MultiConnectionManager {
+    primary;
+    backup = null;
+    config;
+    events;
+    seenIds = new Set();
+    seenOrder = [];
+    constructor(config, events) {
+        this.config = config;
+        this.events = events;
+        this.primary = new ws_client_1.WebSocketManager(config, {
+            onData: (msg) => this.handleData(msg),
+            onConnected: events.onConnected,
+            onDisconnected: events.onDisconnected,
+        });
+    }
+    /** primary の接続を開始する */
+    async connect() {
+        await this.primary.connect();
+    }
+    /** primary の接続状態を返す */
+    getStatus() {
+        return this.primary.getStatus();
+    }
+    /** primary と backup の両方を停止する */
+    close() {
+        this.primary.close();
+        if (this.backup) {
+            this.backup.close();
+            this.backup = null;
+        }
+    }
+    /** 全ソケットの ID を返す (シャットダウン時の API クローズ用) */
+    getAllSocketIds() {
+        const ids = [];
+        const primaryId = this.primary.getStatus().socketId;
+        if (primaryId != null)
+            ids.push(primaryId);
+        if (this.backup) {
+            const backupId = this.backup.getStatus().socketId;
+            if (backupId != null)
+                ids.push(backupId);
+        }
+        return ids;
+    }
+    /** backup の接続状態を返す (未起動時は null) */
+    getBackupStatus() {
+        return this.backup?.getStatus() ?? null;
+    }
+    /** backup が起動中か */
+    isBackupRunning() {
+        return this.backup != null;
+    }
+    /** EEW 副回線を起動する。戻り値で起動結果を返す */
+    async startBackup() {
+        if (this.backup) {
+            log.warn("副回線は既に起動中です");
+            return "already_running";
+        }
+        // EEW 区分と契約済み区分の積集合
+        const backupClassifications = this.config.classifications.filter((c) => EEW_CLASSIFICATIONS.includes(c));
+        if (backupClassifications.length === 0) {
+            log.warn("EEW 区分 (eew.forecast, eew.warning) が契約に含まれていないため、副回線を起動できません");
+            return "no_eew_contract";
+        }
+        const backupConfig = {
+            ...this.config,
+            classifications: backupClassifications,
+            appName: `${this.config.appName}-backup`,
+            keepExistingConnections: true,
+        };
+        this.backup = new ws_client_1.WebSocketManager(backupConfig, {
+            onData: (msg) => this.handleData(msg),
+            onConnected: () => {
+                log.info("副回線: 接続成功");
+            },
+            onDisconnected: (reason) => {
+                log.warn(`副回線: 切断 — ${reason}`);
+            },
+        });
+        log.info("副回線を起動中...");
+        await this.backup.connect();
+        return "started";
+    }
+    /** EEW 副回線を停止する */
+    stopBackup() {
+        if (!this.backup) {
+            log.warn("副回線は起動していません");
+            return;
+        }
+        this.backup.close();
+        this.backup = null;
+        log.info("副回線を停止しました");
+    }
+    /** 重複排除付きデータハンドラ */
+    handleData(msg) {
+        if (this.seenIds.has(msg.id)) {
+            log.debug(`重複排除: id=${msg.id.slice(0, 16)}...`);
+            return;
+        }
+        // FIFO window: 古い ID を先頭から削除
+        this.seenIds.add(msg.id);
+        this.seenOrder.push(msg.id);
+        while (this.seenOrder.length > SEEN_IDS_MAX) {
+            const oldest = this.seenOrder.shift();
+            if (oldest)
+                this.seenIds.delete(oldest);
+        }
+        this.events.onData(msg);
+    }
+}
+exports.MultiConnectionManager = MultiConnectionManager;

package/dist/dmdata/rest-client.js

@@ -0,0 +1,281 @@
+"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 __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.listContracts = listContracts;
+exports.listEarthquakes = listEarthquakes;
+exports.listTelegrams = listTelegrams;
+exports.listSockets = listSockets;
+exports.closeSocket = closeSocket;
+exports.startSocket = startSocket;
+exports.prepareAndStartSocket = prepareAndStartSocket;
+const https_1 = __importDefault(require("https"));
+const log = __importStar(require("../logger"));
+const API_BASE = "https://api.dmdata.jp/v2";
+const REQUEST_TIMEOUT_MS = 15_000;
+const SOCKET_CLEANUP_MAX_RETRIES = 5;
+const SOCKET_CLEANUP_RETRY_INTERVAL_MS = 500;
+/** TLS ハンドシェイクを再利用するための keep-alive エージェント (遅延初期化) */
+let keepAliveAgent = null;
+function getKeepAliveAgent() {
+    if (keepAliveAgent == null) {
+        keepAliveAgent = new https_1.default.Agent({ keepAlive: true });
+    }
+    return keepAliveAgent;
+}
+/** dmdata.jp REST API の推奨方式に合わせて Basic 認証ヘッダーを構築 */
+function buildAuthorizationHeader(apiKey) {
+    return `Basic ${Buffer.from(`${apiKey}:`).toString("base64")}`;
+}
+/** HTTPS リクエストを Promise でラップ */
+function request(method, url, apiKey, body) {
+    return new Promise((resolve, reject) => {
+        const parsed = new URL(url);
+        const options = {
+            hostname: parsed.hostname,
+            port: 443,
+            path: parsed.pathname + parsed.search,
+            method,
+            agent: getKeepAliveAgent(),
+            headers: {
+                Accept: "application/json",
+                Authorization: buildAuthorizationHeader(apiKey),
+                "Content-Type": "application/json",
+            },
+        };
+        const req = https_1.default.request(options, (res) => {
+            const statusCode = res.statusCode ?? 0;
+            let data = "";
+            res.on("data", (chunk) => (data += chunk));
+            res.on("end", () => {
+                // 204 No Content は成功（ボディなし）なのでそのまま返す
+                if (statusCode === 204) {
+                    resolve({});
+                    return;
+                }
+                // Content-Type チェック
+                const contentType = res.headers["content-type"] || "";
+                if (!contentType.includes("application/json")) {
+                    reject(new Error(`${method} ${parsed.pathname}: 予期しない Content-Type: ${contentType} (status=${statusCode}, body=${data.slice(0, 200)})`));
+                    return;
+                }
+                try {
+                    const json = JSON.parse(data);
+                    // HTTP ステータスコードの検証
+                    if (statusCode < 200 || statusCode >= 300) {
+                        const errMsg = typeof json === "object" && json != null && "error" in json
+                            ? json.error?.message || "Unknown error"
+                            : data.slice(0, 200);
+                        reject(new Error(`${method} ${parsed.pathname}: HTTP ${statusCode}: ${errMsg}`));
+                        return;
+                    }
+                    resolve(json);
+                }
+                catch {
+                    reject(new Error(`${method} ${parsed.pathname}: JSON パース失敗 (status=${statusCode}): ${data.slice(0, 200)}`));
+                }
+            });
+        });
+        req.on("error", reject);
+        req.setTimeout(REQUEST_TIMEOUT_MS, () => {
+            req.destroy(new Error(`Request timeout (${REQUEST_TIMEOUT_MS / 1000}s)`));
+        });
+        if (body) {
+            req.write(JSON.stringify(body));
+        }
+        req.end();
+    });
+}
+/** 契約一覧を取得し、有効な区分を返す */
+async function listContracts(apiKey) {
+    log.debug("GET /v2/contract");
+    const res = (await request("GET", `${API_BASE}/contract`, apiKey));
+    if (res.status === "error") {
+        throw new Error(`Contract List failed: ${res.error?.message} (code: ${res.error?.code})`);
+    }
+    const validClassifications = res.items
+        .filter((item) => item.isValid)
+        .map((item) => item.classification);
+    log.debug(`契約済み区分: ${validClassifications.join(", ") || "(なし)"}`);
+    return validClassifications;
+}
+/** 地震履歴を取得 */
+async function listEarthquakes(apiKey, limit = 10) {
+    log.debug(`GET /v2/gd/earthquake?limit=${limit}`);
+    const res = (await request("GET", `${API_BASE}/gd/earthquake?limit=${limit}`, apiKey));
+    if (res.status === "error") {
+        throw new Error(`Earthquake List failed: ${res.error?.message} (code: ${res.error?.code})`);
+    }
+    return res;
+}
+/** 電文リストを取得 (GET /v2/telegram) */
+async function listTelegrams(apiKey, type, limit = 1) {
+    const params = new URLSearchParams({
+        type,
+        limit: String(limit),
+        formatMode: "raw",
+    });
+    log.debug(`GET /v2/telegram?${params}`);
+    const res = (await request("GET", `${API_BASE}/telegram?${params}`, apiKey));
+    if (res.status === "error") {
+        throw new Error(`Telegram List failed: ${res.error?.message} (code: ${res.error?.code})`);
+    }
+    return res;
+}
+/** 既存のオープンソケットを取得 */
+async function listSockets(apiKey) {
+    log.debug("GET /v2/socket?status=open");
+    const res = (await request("GET", `${API_BASE}/socket?status=open`, apiKey));
+    if (res.status === "error") {
+        throw new Error(`Socket List failed: ${res.error?.message} (code: ${res.error?.code})`);
+    }
+    return res;
+}
+/** 既存ソケットを閉じる */
+async function closeSocket(apiKey, socketId) {
+    log.debug(`DELETE /v2/socket/${socketId}`);
+    const res = (await request("DELETE", `${API_BASE}/socket/${socketId}`, apiKey));
+    if (res.status === "error") {
+        log.warn(`Socket Close failed for id=${socketId}: ${res.error?.message}`);
+    }
+    else {
+        log.info(`既存ソケット id=${socketId} をクローズしました`);
+    }
+}
+/** Socket Start: WebSocket接続用チケットを取得 */
+async function startSocket(config) {
+    const body = {
+        classifications: config.classifications,
+        test: config.testMode,
+        appName: config.appName,
+        formatMode: "raw",
+    };
+    log.debug(`POST /v2/socket body=${JSON.stringify(body)}`);
+    const res = (await request("POST", `${API_BASE}/socket`, config.apiKey, body));
+    if (res.status === "error") {
+        throw new Error(`Socket Start failed: ${res.error?.message} (code: ${res.error?.code})`);
+    }
+    return res;
+}
+/** サーバー側でソケット削除が反映されるのを待つ */
+async function awaitSocketCleanup(apiKey, closedIds) {
+    for (let attempt = 1; attempt <= SOCKET_CLEANUP_MAX_RETRIES; attempt++) {
+        await new Promise((r) => setTimeout(r, SOCKET_CLEANUP_RETRY_INTERVAL_MS));
+        try {
+            const list = await listSockets(apiKey);
+            const stillOpen = list.items.filter((s) => s.status === "open" && closedIds.includes(s.id));
+            if (stillOpen.length === 0) {
+                log.debug(`ソケット削除の反映を確認 (${attempt} 回目)`);
+                return;
+            }
+            log.debug(`ソケット削除待機中... 残存 ${stillOpen.length} 件 (${attempt}/${SOCKET_CLEANUP_MAX_RETRIES})`);
+        }
+        catch {
+            // リスト取得失敗は無視して次のリトライへ
+        }
+    }
+    log.warn("ソケット削除の反映を確認できませんでしたが、続行します");
+}
+/** 既存のオープン接続をすべて閉じてから Socket Start する */
+async function prepareAndStartSocket(config, previousSocketId) {
+    /** クリーンアップで DELETE を送信したソケット ID */
+    const closedIds = [];
+    if (!config.keepExistingConnections) {
+        // 同一 appName のオープンソケットを閉じる（他デバイスのソケットは維持）
+        try {
+            const list = await listSockets(config.apiKey);
+            const allOpen = list.items.filter((s) => s.status === "open");
+            log.debug(`オープンソケット一覧 (${allOpen.length} 件): ${allOpen.map((s) => `id=${s.id},appName=${s.appName ?? "(null)"}`).join("; ") || "(なし)"}`);
+            log.debug(`自アプリ名: "${config.appName}", keepExisting=${config.keepExistingConnections}`);
+            const openSockets = allOpen.filter((s) => s.appName === config.appName);
+            if (openSockets.length > 0) {
+                const skipped = allOpen.filter((s) => s.appName !== config.appName).length;
+                if (skipped > 0) {
+                    log.info(`他アプリの ${skipped} 件のソケットは維持します`);
+                }
+                await Promise.allSettled(openSockets.map((sock) => closeSocket(config.apiKey, sock.id)));
+                closedIds.push(...openSockets.map((s) => s.id));
+            }
+        }
+        catch (err) {
+            log.warn(`既存ソケット確認中にエラー: ${err instanceof Error ? err.message : err}`);
+        }
+    }
+    else if (previousSocketId != null) {
+        // 再接続: 自分の旧接続だけを閉じる (サーバー側で既に閉じられている場合は 404 が返る)
+        try {
+            await closeSocket(config.apiKey, previousSocketId);
+            closedIds.push(previousSocketId);
+        }
+        catch (err) {
+            const errMsg = err instanceof Error ? err.message : String(err);
+            if (errMsg.includes("404")) {
+                log.debug(`旧ソケット(id=${previousSocketId})は既にサーバー側で閉じられています`);
+            }
+            else {
+                log.warn(`旧ソケット(id=${previousSocketId})のクローズに失敗: ${errMsg}`);
+            }
+        }
+    }
+    else {
+        // 初回起動: 前回セッションの残留ソケットをクリーンアップ
+        // appName でフィルタリングし、他デバイスのソケットを誤って閉じないようにする
+        try {
+            const list = await listSockets(config.apiKey);
+            const allOpen = list.items.filter((s) => s.status === "open");
+            log.debug(`オープンソケット一覧 (${allOpen.length} 件): ${allOpen.map((s) => `id=${s.id},appName=${s.appName ?? "(null)"}`).join("; ") || "(なし)"}`);
+            log.debug(`自アプリ名: "${config.appName}", keepExisting=${config.keepExistingConnections}`);
+            const openSockets = allOpen.filter((s) => s.appName === config.appName);
+            if (openSockets.length > 0) {
+                const skipped = allOpen.filter((s) => s.appName !== config.appName).length;
+                log.info(`前回セッションの残留ソケットを ${openSockets.length} 件クローズします` +
+                    (skipped > 0 ? ` (他アプリの ${skipped} 件は維持)` : ""));
+                await Promise.allSettled(openSockets.map((sock) => closeSocket(config.apiKey, sock.id)));
+                closedIds.push(...openSockets.map((s) => s.id));
+            }
+        }
+        catch (err) {
+            log.warn(`残留ソケット確認中にエラー: ${err instanceof Error ? err.message : err}`);
+        }
+    }
+    // ソケットを閉じた場合、サーバー側で削除が反映されるのを待ってから新規作成する
+    // (反映前に POST /v2/socket すると同時接続上限を超過し、他デバイスが切断される)
+    if (closedIds.length > 0) {
+        await awaitSocketCleanup(config.apiKey, closedIds);
+    }
+    return startSocket(config);
+}