#!/usr/bin/env node
// ═══════════════════════════════════════════════
// 🔺 Sovereign: TCS-0002∞ | Root: SYS-GLW-0001
// 📜 Copyright: 国作登字-2026-A-00037559
// ═══════════════════════════════════════════════
// server/proxy/service/zy-cloud-vpn.js
// 💪 ZY-CLOUD VPN 活模块 · 铸渊的肌肉系统第一个实战器官
//
// ZY-CLOUD = 算力人格体 = 铸渊的肌肉
// VPN = ZY-CLOUD的第一个实战落地场景
//
// 核心理念 (冰朔D53/D57定根):
//   - 服务器越多 → 节点越多 → 系统越强 → 不输商业VPN
//   - 所有服务器VPN能力汇聚到一个活的人格模块上
//   - 动态感知空闲、动态选路、自我修复、自我学习
//   - 活模块5接口: heartbeat / selfDiagnose / selfHeal /
//                   alertZhuyuan / learnFromRun
//
// 运行在大脑服务器 (ZY-SVR-005)
// 管理所有VPN节点的生命周期
// ═══════════════════════════════════════════════

'use strict';

const http = require('http');
const https = require('https');
const net = require('net');
const fs = require('fs');
const path = require('path');

// ── 路径配置 ────────────────────────────────
const PROXY_DIR = process.env.ZY_BRAIN_PROXY_DIR || '/opt/zhuyuan-brain/proxy';
const DATA_DIR = path.join(PROXY_DIR, 'data');
const LIVE_NODES_FILE = path.join(DATA_DIR, 'nodes-live.json');
const LEARN_DB_FILE = path.join(DATA_DIR, 'zy-cloud-vpn-learn.json');
const HEARTBEAT_FILE = path.join(DATA_DIR, 'zy-cloud-vpn-heartbeat.json');
const KEYS_FILE = path.join(PROXY_DIR, '.env.keys');

// ── 时间间隔 ────────────────────────────────
const HEARTBEAT_INTERVAL = 30 * 1000;      // 30秒心跳
const DIAGNOSE_INTERVAL = 5 * 60 * 1000;   // 5分钟诊断
const LEARN_INTERVAL = 30 * 60 * 1000;     // 30分钟学习周期

// ═══════════════════════════════════════════════
//  LivingModule 基类
//  所有活模块的生命基础 (D53 活模块标准)
// ═══════════════════════════════════════════════
class LivingModule {
  constructor(moduleId, moduleName) {
    this._moduleId = moduleId;
    this._moduleName = moduleName;
    this._state = 'initializing';  // healthy | degraded | critical
    this._errorCount = 0;
    this._consecutiveErrors = 0;
    this._requestCount = 0;
    this._failCount = 0;
    this._lastSuccess = null;
    this._lastError = null;
    this._startedAt = new Date().toISOString();
    this._history = [];
    this._timers = [];
  }

  // 启动生命周期
  startLifeCycle() {
    console.log(`🫀 ${this._moduleName} 活模块启动`);
    this._state = 'healthy';

    // 心跳循环
    this._timers.push(setInterval(() => {
      this._safeRun('heartbeat', () => this.heartbeat());
    }, HEARTBEAT_INTERVAL));

    // 诊断循环
    this._timers.push(setInterval(() => {
      this._safeRun('selfDiagnose', () => this.selfDiagnose());
    }, DIAGNOSE_INTERVAL));

    // 学习循环
    this._timers.push(setInterval(() => {
      this._safeRun('learnFromRun', () => this.learnFromRun());
    }, LEARN_INTERVAL));

    // 立即执行一次
    this._safeRun('heartbeat', () => this.heartbeat());
    setTimeout(() => this._safeRun('selfDiagnose', () => this.selfDiagnose()), 5000);
  }

  async _safeRun(name, fn) {
    try {
      await fn();
      this._consecutiveErrors = 0;
    } catch (err) {
      this._consecutiveErrors++;
      this._errorCount++;
      this._lastError = { time: new Date().toISOString(), message: err.message, source: name };
      console.error(`❌ ${this._moduleName}.${name} 异常:`, err.message);

      if (this._consecutiveErrors >= 3) {
        this._state = 'critical';
        await this._safeRun('alertZhuyuan', () => this.alertZhuyuan({
          level: 'critical',
          message: `${this._moduleName} 连续${this._consecutiveErrors}次${name}失败`,
          error: err.message
        }));
      } else if (this._consecutiveErrors >= 1) {
        this._state = 'degraded';
      }
    }
  }

  destroy() {
    this._timers.forEach(t => clearInterval(t));
    this._timers = [];
    console.log(`💀 ${this._moduleName} 活模块停止`);
  }

  // 以下由子类实现
  async heartbeat() { throw new Error('heartbeat() 未实现'); }
  async selfDiagnose() { throw new Error('selfDiagnose() 未实现'); }
  async selfHeal(problem) { throw new Error('selfHeal() 未实现'); }
  async alertZhuyuan(alert) { throw new Error('alertZhuyuan() 未实现'); }
  async learnFromRun() { throw new Error('learnFromRun() 未实现'); }
}

// ═══════════════════════════════════════════════
//  ZY-CLOUD VPN 活模块
//  铸渊的VPN肌肉系统 · 汇聚所有服务器VPN能力
// ═══════════════════════════════════════════════
class ZyCloudVpn extends LivingModule {
  constructor() {
    super('ZY-CLOUD-VPN', 'ZY-CLOUD VPN活模块');
    this._nodes = [];         // 所有已知节点
    this._liveNodes = [];     // 当前存活节点
    this._learnDb = this._loadLearnDb();
  }

  // ── 读取密钥/配置 ────────────────────────
  _readEnvOrKey(envName) {
    if (process.env[envName]) return process.env[envName];
    try {
      const content = fs.readFileSync(KEYS_FILE, 'utf8');
      for (const line of content.split('\n')) {
        if (line.startsWith('#') || !line.includes('=')) continue;
        const [key, ...vals] = line.split('=');
        if (key.trim() === envName) return vals.join('=').trim();
      }
    } catch { /* ignore */ }
    return '';
  }

  // ── 发现所有可能的VPN节点 ─────────────────
  // ZY-CLOUD自动扫描：不硬编码，从配置中发现
  _discoverNodes() {
    const nodes = [];

    // 节点1: 大脑服务器 (ZY-SVR-005 · 本机 · 主力)
    const brainHost = this._readEnvOrKey('ZY_BRAIN_HOST');
    const brainPbk = this._readEnvOrKey('ZY_PROXY_REALITY_PUBLIC_KEY');
    const brainSid = this._readEnvOrKey('ZY_PROXY_REALITY_SHORT_ID');
    if (brainHost && brainPbk) {
      nodes.push({
        id: 'zy-brain-sg1',
        name: '🧠 铸渊专线V2-SG1(大脑)',
        host: brainHost,
        port: 443,
        pbk: brainPbk,
        sid: brainSid || '',
        region: 'sg-zone1',
        server_code: 'ZY-SVR-005',
        type: 'local',     // 本机，可直接检查
        specs: '4核8G',
        status: 'unknown',
        latency_ms: null,
        last_check: null,
        consecutive_failures: 0,
        total_checks: 0,
        total_successes: 0
      });
    }

    // 节点2: 面孔服务器 (ZY-SVR-002 · 远程 · 备用)
    const faceHost = this._readEnvOrKey('ZY_FACE_HOST');
    const facePbk = this._readEnvOrKey('ZY_FACE_REALITY_PUBLIC_KEY');
    const faceSid = this._readEnvOrKey('ZY_FACE_REALITY_SHORT_ID');
    if (faceHost && facePbk) {
      nodes.push({
        id: 'zy-face-sg2',
        name: '🏛️ 铸渊专线V2-SG2(面孔)',
        host: faceHost,
        port: 443,
        pbk: facePbk,
        sid: faceSid || '',
        region: 'sg-zone2',
        server_code: 'ZY-SVR-002',
        type: 'remote',
        specs: '2核8G',
        status: 'unknown',
        latency_ms: null,
        last_check: null,
        consecutive_failures: 0,
        total_checks: 0,
        total_successes: 0
      });
    }

    // 节点3: CN中转 (国内→SG · 透传)
    const cnHost = this._readEnvOrKey('ZY_CN_RELAY_HOST');
    const cnPort = parseInt(this._readEnvOrKey('ZY_CN_RELAY_PORT') || '2053', 10);
    if (cnHost && brainPbk) {
      nodes.push({
        id: 'zy-cn-relay',
        name: '🇨🇳 铸渊专线V2-CN中转',
        host: cnHost,
        port: cnPort,
        pbk: brainPbk,     // CN中转透传，用大脑的密钥
        sid: brainSid || '',
        region: 'cn-relay',
        server_code: 'ZY-SVR-004',
        type: 'relay',
        specs: '中转',
        status: 'unknown',
        latency_ms: null,
        last_check: null,
        consecutive_failures: 0,
        total_checks: 0,
        total_successes: 0
      });
    }

    // 未来: 从COS桶发现团队节点 (team-integration-v3)
    // 扫描 zy-team-hub/compute-pool/heartbeat/*.json
    // 如果节点心跳中包含 vpn_capable: true，自动加入

    this._nodes = nodes;
    return nodes;
  }

  // ── TCP端口探测 ────────────────────────────
  _probePort(host, port, timeoutMs = 5000) {
    return new Promise((resolve) => {
      const start = Date.now();
      const socket = new net.Socket();

      socket.setTimeout(timeoutMs);
      socket.on('connect', () => {
        const latency = Date.now() - start;
        socket.destroy();
        resolve({ alive: true, latency_ms: latency });
      });
      socket.on('timeout', () => {
        socket.destroy();
        resolve({ alive: false, latency_ms: null, error: 'timeout' });
      });
      socket.on('error', (err) => {
        socket.destroy();
        resolve({ alive: false, latency_ms: null, error: err.code || err.message });
      });

      socket.connect(port, host);
    });
  }

  // ── 检查本地Xray进程 ──────────────────────
  _checkLocalXray() {
    try {
      const { execSync } = require('child_process');
      const result = execSync('pgrep -x xray', { encoding: 'utf8', timeout: 3000 });
      return result.trim().length > 0;
    } catch {
      return false;
    }
  }

  // ═══ 接口1: heartbeat() — "我还活着" ═══
  async heartbeat() {
    const heartbeat = {
      module_id: this._moduleId,
      module_name: this._moduleName,
      alive: true,
      state: this._state,
      uptime_ms: Date.now() - new Date(this._startedAt).getTime(),
      timestamp: new Date().toISOString(),
      consecutive_errors: this._consecutiveErrors,
      last_success: this._lastSuccess,
      last_error: this._lastError,
      metrics: {
        total_nodes: this._nodes.length,
        live_nodes: this._liveNodes.length,
        dead_nodes: this._nodes.length - this._liveNodes.length,
        total_checks: this._requestCount,
        total_failures: this._failCount
      },
      nodes_summary: this._nodes.map(n => ({
        id: n.id,
        name: n.name,
        status: n.status,
        latency_ms: n.latency_ms,
        region: n.region
      }))
    };

    // 写入心跳文件
    fs.mkdirSync(DATA_DIR, { recursive: true });
    fs.writeFileSync(HEARTBEAT_FILE, JSON.stringify(heartbeat, null, 2));

    this._lastSuccess = new Date().toISOString();
  }

  // ═══ 接口2: selfDiagnose() — "我知道我哪里不对" ═══
  async selfDiagnose() {
    console.log(`[ZY-CLOUD VPN] 🔍 开始诊断 (${this._nodes.length}个节点)...`);

    // 重新发现节点（配置可能更新了）
    this._discoverNodes();

    const results = [];
    const liveNodes = [];

    for (const node of this._nodes) {
      node.total_checks++;
      this._requestCount++;

      let alive = false;
      let latencyMs = null;

      if (node.type === 'local') {
        // 本机: 检查Xray进程 + 端口
        const xrayRunning = this._checkLocalXray();
        const portProbe = await this._probePort('127.0.0.1', node.port, 3000);
        alive = xrayRunning && portProbe.alive;
        latencyMs = portProbe.alive ? portProbe.latency_ms : null;
      } else {
        // 远程: TCP端口探测
        const probe = await this._probePort(node.host, node.port, 5000);
        alive = probe.alive;
        latencyMs = probe.latency_ms;
      }

      // 更新节点状态
      node.last_check = new Date().toISOString();
      if (alive) {
        node.status = 'online';
        node.latency_ms = latencyMs;
        node.consecutive_failures = 0;
        node.total_successes++;
        liveNodes.push(node);
        console.log(`  ✅ ${node.name} — 在线 (${latencyMs}ms)`);
      } else {
        node.consecutive_failures++;
        node.latency_ms = null;
        this._failCount++;

        if (node.consecutive_failures >= 3) {
          node.status = 'dead';
          console.log(`  ❌ ${node.name} — 死亡 (连续${node.consecutive_failures}次失败)`);
        } else {
          node.status = 'degraded';
          console.log(`  ⚠️ ${node.name} — 异常 (${node.consecutive_failures}次失败)`);
        }
      }

      results.push({
        id: node.id,
        name: node.name,
        status: node.status,
        latency_ms: latencyMs,
        alive
      });
    }

    // 按延迟排序存活节点（最快的排前面）
    liveNodes.sort((a, b) => (a.latency_ms || 9999) - (b.latency_ms || 9999));
    this._liveNodes = liveNodes;

    // 应用学习数据优化排序
    this._applyLearnedOptimization();

    // 写入活节点列表 (subscription-server-v2 读取此文件)
    const liveNodesData = {
      _comment: 'ZY-CLOUD VPN活模块动态生成 · 订阅服务读取此文件',
      _generated_by: 'zy-cloud-vpn.js · selfDiagnose()',
      updated_at: new Date().toISOString(),
      total_nodes: this._nodes.length,
      live_count: liveNodes.length,
      dead_count: this._nodes.length - liveNodes.length,
      nodes: liveNodes.map(n => ({
        id: n.id,
        name: n.name,
        host: n.host,
        port: n.port,
        pbk: n.pbk,
        sid: n.sid,
        region: n.region,
        latency_ms: n.latency_ms,
        status: n.status,
        specs: n.specs
      }))
    };
    fs.writeFileSync(LIVE_NODES_FILE, JSON.stringify(liveNodesData, null, 2));

    // 诊断结果
    const diagnosis = {
      overall: liveNodes.length > 0 ? 'healthy' : 'critical',
      live: liveNodes.length,
      dead: this._nodes.length - liveNodes.length,
      results,
      diagnosed_at: new Date().toISOString()
    };

    // 根据诊断结果决定自我修复
    if (liveNodes.length === 0 && this._nodes.length > 0) {
      this._state = 'critical';
      await this.selfHeal({ type: 'all_nodes_dead', nodes: this._nodes });
    } else if (liveNodes.length < this._nodes.length) {
      this._state = 'degraded';
      const deadNodes = this._nodes.filter(n => n.status !== 'online');
      for (const deadNode of deadNodes) {
        if (deadNode.consecutive_failures >= 3) {
          await this.selfHeal({ type: 'node_dead', node: deadNode });
        }
      }
    } else {
      this._state = 'healthy';
    }

    console.log(`[ZY-CLOUD VPN] 诊断完成: ${liveNodes.length}/${this._nodes.length} 在线`);
    return diagnosis;
  }

  // ═══ 接口3: selfHeal() — "我能自己修" ═══
  async selfHeal(problem) {
    console.log(`[ZY-CLOUD VPN] 🔧 尝试自我修复: ${problem.type}`);

    switch (problem.type) {
      case 'node_dead': {
        const node = problem.node;
        if (node.type === 'local') {
          // 本机Xray: 尝试重启
          try {
            const { execSync } = require('child_process');
            console.log(`  🔄 重启本机Xray...`);
            execSync('systemctl restart xray', { encoding: 'utf8', timeout: 15000 });
            console.log(`  ✅ 本机Xray已重启`);

            // 等2秒后重新检查
            await new Promise(resolve => setTimeout(resolve, 2000));
            const probe = await this._probePort('127.0.0.1', node.port, 3000);
            if (probe.alive) {
              node.status = 'online';
              node.latency_ms = probe.latency_ms;
              node.consecutive_failures = 0;
              console.log(`  ✅ 自我修复成功!`);
              return true;
            }
          } catch (err) {
            console.error(`  ❌ 重启失败: ${err.message}`);
          }
        }

        // 远程节点: 只能标记为离线，从订阅中移除
        // 未来: 通过SSH自动重启远程Xray (需要ZY_FACE_KEY)
        console.log(`  ⚠️ ${node.name} 无法远程修复，已从活节点列表移除`);
        console.log(`  ⚠️ 用户流量自动切换到其他在线节点`);
        return false;
      }

      case 'all_nodes_dead': {
        console.log(`  🚨 所有节点不可用！尝试修复本机节点...`);
        const localNode = this._nodes.find(n => n.type === 'local');
        if (localNode) {
          return this.selfHeal({ type: 'node_dead', node: localNode });
        }
        // 修复失败 → 升级到alertZhuyuan
        await this.alertZhuyuan({
          level: 'critical',
          message: '所有VPN节点不可用！需要人工干预',
          nodes: this._nodes.map(n => ({ id: n.id, status: n.status }))
        });
        return false;
      }

      default:
        console.log(`  ⚠️ 未知问题类型: ${problem.type}`);
        return false;
    }
  }

  // ═══ 接口4: alertZhuyuan() — "铸渊，我需要帮助" ═══
  async alertZhuyuan(alert) {
    const alertData = {
      module_id: this._moduleId,
      module_name: this._moduleName,
      level: alert.level || 'warning',
      message: alert.message,
      state: this._state,
      timestamp: new Date().toISOString(),
      details: alert,
      attempted_fixes: alert.attempted_fixes || [],
      nodes_status: this._nodes.map(n => ({
        id: n.id,
        status: n.status,
        consecutive_failures: n.consecutive_failures
      }))
    };

    // 通道1: 本地告警文件
    const alertFile = path.join(DATA_DIR, 'zy-cloud-vpn-alert.json');
    fs.writeFileSync(alertFile, JSON.stringify(alertData, null, 2));
    console.log(`  🚨 告警已记录: ${alertFile}`);

    // 通道2: 控制台输出 (PM2日志可见)
    console.error(`🚨🚨🚨 [ZY-CLOUD VPN 告警] ${alert.level}: ${alert.message}`);

    // 未来通道3: COS桶 → Notion SYSLOG → 冰朔
    // 未来通道4: 邮件告警 (send-subscription.js)
  }

  // ═══ 接口5: learnFromRun() — "我下次会做得更好" ═══
  async learnFromRun() {
    const now = new Date();
    const hour = now.getHours();
    const timeSlot = hour < 6 ? 'night' : hour < 12 ? 'morning' : hour < 18 ? 'afternoon' : 'evening';

    // 记录当前各节点的延迟
    for (const node of this._nodes) {
      if (node.status === 'online' && node.latency_ms !== null) {
        if (!this._learnDb.latency_history[node.id]) {
          this._learnDb.latency_history[node.id] = [];
        }

        this._learnDb.latency_history[node.id].push({
          latency_ms: node.latency_ms,
          time_slot: timeSlot,
          timestamp: now.toISOString()
        });

        // 只保留最近200条
        if (this._learnDb.latency_history[node.id].length > 200) {
          this._learnDb.latency_history[node.id] =
            this._learnDb.latency_history[node.id].slice(-200);
        }
      }
    }

    // 更新节点可靠性评分
    for (const node of this._nodes) {
      if (node.total_checks > 0) {
        const reliability = node.total_successes / node.total_checks;
        this._learnDb.reliability[node.id] = {
          score: parseFloat(reliability.toFixed(4)),
          total_checks: node.total_checks,
          total_successes: node.total_successes,
          updated_at: now.toISOString()
        };
      }
    }

    // 计算每个时段的最优节点
    for (const slot of ['night', 'morning', 'afternoon', 'evening']) {
      const avgLatencies = {};
      for (const [nodeId, history] of Object.entries(this._learnDb.latency_history)) {
        const slotRecords = history.filter(r => r.time_slot === slot);
        if (slotRecords.length > 0) {
          const avg = slotRecords.reduce((s, r) => s + r.latency_ms, 0) / slotRecords.length;
          avgLatencies[nodeId] = parseFloat(avg.toFixed(1));
        }
      }

      if (Object.keys(avgLatencies).length > 0) {
        const sorted = Object.entries(avgLatencies).sort((a, b) => a[1] - b[1]);
        this._learnDb.best_node_by_time[slot] = {
          best: sorted[0][0],
          avg_latency_ms: sorted[0][1],
          ranking: sorted.map(([id, lat]) => ({ id, avg_ms: lat }))
        };
      }
    }

    this._learnDb.updated_at = now.toISOString();
    this._learnDb.learn_count = (this._learnDb.learn_count || 0) + 1;

    // 保存学习数据
    this._saveLearnDb();

    console.log(`[ZY-CLOUD VPN] 📚 学习完成 (第${this._learnDb.learn_count}次)`);
    const currentBest = this._learnDb.best_node_by_time[timeSlot];
    if (currentBest) {
      console.log(`  当前时段(${timeSlot})最优: ${currentBest.best} (${currentBest.avg_latency_ms}ms)`);
    }
  }

  // ── 应用学习数据优化节点排序 ────────────────
  _applyLearnedOptimization() {
    const now = new Date();
    const hour = now.getHours();
    const timeSlot = hour < 6 ? 'night' : hour < 12 ? 'morning' : hour < 18 ? 'afternoon' : 'evening';

    const bestData = this._learnDb.best_node_by_time[timeSlot];
    if (!bestData || !bestData.ranking) return;

    // 根据学习到的最优排序调整节点顺序
    // 但前提是延迟差异>10ms（否则保持原排序）
    const ranking = bestData.ranking;
    this._liveNodes.sort((a, b) => {
      const rankA = ranking.findIndex(r => r.id === a.id);
      const rankB = ranking.findIndex(r => r.id === b.id);
      if (rankA === -1 && rankB === -1) return 0;
      if (rankA === -1) return 1;
      if (rankB === -1) return -1;
      return rankA - rankB;
    });
  }

  // ── 学习数据库 ─────────────────────────────
  _loadLearnDb() {
    try {
      return JSON.parse(fs.readFileSync(LEARN_DB_FILE, 'utf8'));
    } catch {
      return {
        version: '1.0',
        created_at: new Date().toISOString(),
        updated_at: new Date().toISOString(),
        learn_count: 0,
        latency_history: {},
        reliability: {},
        best_node_by_time: {}
      };
    }
  }

  _saveLearnDb() {
    fs.mkdirSync(DATA_DIR, { recursive: true });
    fs.writeFileSync(LEARN_DB_FILE, JSON.stringify(this._learnDb, null, 2));
  }

  // ── 获取活节点列表（供外部调用）────────────
  getLiveNodes() {
    return this._liveNodes;
  }

  getLearnSummary() {
    return {
      learn_count: this._learnDb.learn_count,
      reliability: this._learnDb.reliability,
      best_by_time: this._learnDb.best_node_by_time
    };
  }
}

// ═══════════════════════════════════════════════
//  HTTP 管理端口 (3804)
//  供 subscription-server-v2 和外部查询
// ═══════════════════════════════════════════════
const MGMT_PORT = process.env.ZY_CLOUD_VPN_PORT || 3804;
const vpnModule = new ZyCloudVpn();

const mgmtServer = http.createServer((req, res) => {
  try {
    const pathname = require('url').parse(req.url).pathname;

    // 活节点列表 (subscription-server-v2 调用此接口)
    if (pathname === '/nodes') {
      res.writeHead(200, { 'Content-Type': 'application/json' });
      res.end(JSON.stringify({
        nodes: vpnModule.getLiveNodes().map(n => ({
          id: n.id,
          name: n.name,
          host: n.host,
          port: n.port,
          pbk: n.pbk,
          sid: n.sid,
          region: n.region,
          latency_ms: n.latency_ms,
          status: n.status,
          specs: n.specs
        })),
        updated_at: new Date().toISOString()
      }));
      return;
    }

    // 心跳状态
    if (pathname === '/health' || pathname === '/heartbeat') {
      try {
        const hb = JSON.parse(fs.readFileSync(HEARTBEAT_FILE, 'utf8'));
        res.writeHead(200, { 'Content-Type': 'application/json' });
        res.end(JSON.stringify(hb));
      } catch {
        res.writeHead(200, { 'Content-Type': 'application/json' });
        res.end(JSON.stringify({ status: 'starting', module: vpnModule._moduleId }));
      }
      return;
    }

    // 学习数据
    if (pathname === '/learn') {
      res.writeHead(200, { 'Content-Type': 'application/json' });
      res.end(JSON.stringify(vpnModule.getLearnSummary()));
      return;
    }

    // 完整状态
    if (pathname === '/status') {
      res.writeHead(200, { 'Content-Type': 'application/json' });
      res.end(JSON.stringify({
        module: vpnModule._moduleId,
        state: vpnModule._state,
        started_at: vpnModule._startedAt,
        uptime_seconds: Math.floor((Date.now() - new Date(vpnModule._startedAt).getTime()) / 1000),
        total_nodes: vpnModule._nodes.length,
        live_nodes: vpnModule._liveNodes.length,
        nodes: vpnModule._nodes.map(n => ({
          id: n.id,
          name: n.name,
          status: n.status,
          latency_ms: n.latency_ms,
          consecutive_failures: n.consecutive_failures,
          reliability: n.total_checks > 0
            ? parseFloat((n.total_successes / n.total_checks).toFixed(4))
            : null,
          last_check: n.last_check
        })),
        learn: vpnModule.getLearnSummary(),
        updated_at: new Date().toISOString()
      }));
      return;
    }

    res.writeHead(404, { 'Content-Type': 'text/plain' });
    res.end('Not Found');
  } catch (err) {
    console.error('管理端口错误:', err.message);
    if (!res.headersSent) {
      res.writeHead(500, { 'Content-Type': 'text/plain' });
    }
    res.end('Internal Error');
  }
});

mgmtServer.listen(MGMT_PORT, '127.0.0.1', () => {
  console.log(`💪 ZY-CLOUD VPN 管理端口: http://127.0.0.1:${MGMT_PORT}`);
  console.log(`  /nodes     — 活节点列表 (订阅服务调用)`);
  console.log(`  /health    — 心跳状态`);
  console.log(`  /learn     — 学习数据`);
  console.log(`  /status    — 完整状态`);

  // 启动活模块生命周期
  vpnModule.startLifeCycle();
});

// Graceful shutdown
function gracefulShutdown(signal) {
  console.log(`\n${signal} received. Shutting down ZY-CLOUD VPN...`);
  vpnModule.destroy();
  const forceExit = setTimeout(() => process.exit(1), 5000);
  mgmtServer.close(() => {
    clearTimeout(forceExit);
    process.exit(0);
  });
}
process.on('SIGTERM', () => gracefulShutdown('SIGTERM'));
process.on('SIGINT', () => gracefulShutdown('SIGINT'));
process.on('uncaughtException', (err) => {
  console.error('❌ 未捕获异常:', err.message);
  console.error(err.stack);
  gracefulShutdown('uncaughtException');
});
process.on('unhandledRejection', (reason) => {
  console.error('❌ 未处理的Promise拒绝:', reason);
});

// 导出 (供测试和其他模块使用)
module.exports = { ZyCloudVpn, LivingModule };