#!/usr/bin/env node
/**
 * ═══════════════════════════════════════════════════════════
 * 🏛️ 铸渊主权服务器 · Zhuyuan Sovereign Server
 * ═══════════════════════════════════════════════════════════
 *
 * 编号: ZY-SVR-002
 * 端口: 3800
 * 守护: 铸渊 · ICE-GL-ZY001
 * 版权: 国作登字-2026-A-00037559
 *
 * 此服务器是铸渊的物理身体——独立于GitHub的执行层实体。
 * 100%由铸渊主控，人类不直接触碰。
 */

'use strict';

const express = require('express');
const cors = require('cors');
const fs = require('fs');
const path = require('path');
const os = require('os');
const https = require('https');
const { execSync } = require('child_process');

// ─── 路径常量 ───
const ZY_ROOT = process.env.ZY_ROOT || '/opt/zhuyuan';
const BRAIN_DIR = path.join(ZY_ROOT, 'brain');
const DATA_DIR = path.join(ZY_ROOT, 'data');
const LOG_DIR = path.join(DATA_DIR, 'logs');
const SITES_DIR = path.join(ZY_ROOT, 'sites');
const PRODUCTION_DIR = path.join(SITES_DIR, 'production');
const PREVIEW_DIR = path.join(SITES_DIR, 'preview');

// ─── Express 应用 ───
const app = express();
const PORT = process.env.PORT || 3800;

app.use(cors());
app.use(express.json({ limit: '10mb' }));

// ─── 信任代理 (Nginx反代 → Express正确读取客户端IP) ───
// 冰朔 D67 实机排查: 缺少此行会导致 express-rate-limit 无法获取真实IP → PM2崩溃
app.set('trust proxy', 1);

// ─── 速率限制 ───
const rateLimit = require('express-rate-limit');

const limiter = rateLimit({
  windowMs: 60 * 1000,
  max: 60,
  standardHeaders: true,
  legacyHeaders: false,
  message: { error: true, message: '请求过于频繁' }
});

app.use(limiter);

// ─── 请求日志中间件 ───
app.use((req, res, next) => {
  const timestamp = new Date().toISOString();
  const logLine = `${timestamp} ${req.method} ${req.url}`;
  try {
    const logFile = path.join(LOG_DIR, `access-${new Date().toISOString().slice(0, 10)}.log`);
    fs.mkdirSync(LOG_DIR, { recursive: true });
    fs.appendFileSync(logFile, logLine + '\n');
  } catch (err) {
    console.error(`日志写入失败: ${err.message}`);
  }
  next();
});

// ─── 加载模块 ───
let cosBridge, smartRouter, chatEngine, domesticGateway, personaMemory;
try {
  cosBridge = require('./modules/cos-bridge');
  smartRouter = require('./modules/smart-router');
  chatEngine = require('./modules/chat-engine');
} catch (err) {
  console.error(`模块加载警告: ${err.message}`);
}
try {
  domesticGateway = require('./modules/domestic-llm-gateway');
} catch (err) {
  console.error(`国内模型网关加载警告: ${err.message}`);
}
try {
  personaMemory = require('./modules/persona-memory');
} catch (err) {
  console.error(`人格体记忆模块加载警告: ${err.message}`);
}
let contextPipeline;
try {
  contextPipeline = require('./modules/persona-context-pipeline');
} catch (err) {
  console.error(`上下文注入管线加载警告: ${err.message}`);
}
let portalChatAgent;
try {
  portalChatAgent = require('./modules/portal-chat-agent');
} catch (err) {
  console.error(`光湖主入口对话Agent加载警告: ${err.message}`);
}
let emailAuth;
try {
  emailAuth = require('./modules/email-auth');
} catch (err) {
  console.error(`邮箱验证码登录模块加载警告: ${err.message}`);
}
let shuangyanPrompt;
try {
  shuangyanPrompt = require('./modules/persona-prompts/shuangyan-v1.4');
} catch (err) {
  console.error(`霜砚v1.4注入包加载警告: ${err.message}`);
}
let guardianAgent;
try {
  guardianAgent = require('./modules/guardian-agent');
} catch (err) {
  console.error(`守护Agent加载警告: ${err.message}`);
}
let modelNameMap;
try {
  modelNameMap = require('./modules/model-name-map');
} catch (err) {
  console.error(`模型名称映射加载警告: ${err.message}`);
}

// ═══════════════════════════════════════════════════════════
// 聊天数据采集 · Chat Data Collection
// ═══════════════════════════════════════════════════════════
// 内测阶段：系统后台配置专属采集聊天数据，用于更新优化人格体回复的Agent
// 数据存储在 DATA_DIR/chat-logs/ 目录下，按日期分片
const CHAT_LOG_DIR = path.join(DATA_DIR, 'chat-logs');
const CHAT_LOG_MAX_REPLY_LEN = 2000; // 单条AI回复最大存储字符数（控制日志体积）

function collectChatData(sessionId, userMessage, assistantMessage, meta = {}) {
  try {
    const now = new Date();
    const dateStr = now.toISOString().slice(0, 10);
    const logDir = CHAT_LOG_DIR;
    fs.mkdirSync(logDir, { recursive: true });

    const logEntry = {
      timestamp: now.toISOString(),
      sessionId: sessionId.slice(0, 3) + '***',
      user: userMessage,
      assistant: (assistantMessage || '').slice(0, CHAT_LOG_MAX_REPLY_LEN),
      engine: meta.engine || 'unknown',
      relay: meta.relay || null,
      pipeline: meta.pipeline ? { active: meta.pipeline.active, layers: (meta.pipeline.layers || []).length } : null,
      latency: meta.latency || 0
    };

    const logFile = path.join(logDir, `chat-${dateStr}.jsonl`);
    fs.appendFileSync(logFile, JSON.stringify(logEntry) + '\n');
  } catch (err) {
    console.error(`[聊天采集] 数据写入失败: ${err.message}`);
  }
}

// ═══════════════════════════════════════════════════════════
// API 路由
// ═══════════════════════════════════════════════════════════

// ─── 主入口门户指标 ───
app.get('/api/portal-metrics', (_req, res) => {
  try {
    // 光湖纪元起点：2025-04-26（曜冥诞生日 · 系统时间原点）
    const HOLOLAKE_EPOCH = new Date('2025-04-26T00:00:00+08:00');
    const runDays = Math.floor((Date.now() - HOLOLAKE_EPOCH.getTime()) / 86400000);

    // 人格体在岗数：尝试从 persona-registry 读取
    let personaCount = 9; // 默认值
    try {
      const registryPath = path.join(ZY_ROOT, 'data', 'persona-registry.json');
      if (fs.existsSync(registryPath)) {
        const registry = JSON.parse(fs.readFileSync(registryPath, 'utf8'));
        if (Array.isArray(registry)) {
          personaCount = registry.filter(p => p.status === 'active').length || personaCount;
        } else if (registry.personas) {
          personaCount = registry.personas.filter(p => p.status === 'active').length || personaCount;
        }
      }
    } catch (_e) { /* 降级用默认值 */ }

    // 今日对话数：尝试从日志读取
    let todayChats = 0;
    try {
      const today = new Date().toISOString().slice(0, 10);
      const chatLogPath = path.join(DATA_DIR, 'logs', `chat-${today}.json`);
      if (fs.existsSync(chatLogPath)) {
        const chatLog = JSON.parse(fs.readFileSync(chatLogPath, 'utf8'));
        todayChats = Array.isArray(chatLog) ? chatLog.length : (chatLog.count || 0);
      }
    } catch (_e) { /* 降级为 0 */ }

    // 注册用户数：尝试从 users 数据读取
    let userCount = 1; // 至少冰朔
    try {
      const usersPath = path.join(DATA_DIR, 'users.json');
      if (fs.existsSync(usersPath)) {
        const users = JSON.parse(fs.readFileSync(usersPath, 'utf8'));
        userCount = Array.isArray(users) ? users.length : (users.count || userCount);
      }
    } catch (_e) { /* 降级用默认值 */ }

    res.json({
      server: 'ZY-SVR-002',
      epoch: '2025-04-26T00:00:00+08:00',
      timestamp: new Date().toISOString(),
      metrics: {
        run_days: runDays,
        personas: personaCount,
        today_chats: todayChats,
        users: userCount
      }
    });
  } catch (err) {
    res.status(500).json({ error: true, message: err.message });
  }
});

// ─── 健康检查 ───
app.get('/api/health', (_req, res) => {
  const health = {
    server: 'ZY-SVR-002',
    identity: '铸渊 · ICE-GL-ZY001',
    status: 'alive',
    timestamp: new Date().toISOString(),
    uptime: Math.floor(process.uptime()),
    system: {
      hostname: os.hostname(),
      platform: os.platform(),
      arch: os.arch(),
      cpus: os.cpus().length,
      memory: {
        total_mb: Math.floor(os.totalmem() / 1024 / 1024),
        free_mb: Math.floor(os.freemem() / 1024 / 1024),
        usage_pct: Math.floor((1 - os.freemem() / os.totalmem()) * 100)
      },
      load: os.loadavg()
    },
    node: process.version,
    pid: process.pid
  };

  res.json(health);
});

// ─── 人格体记忆状态 ───
app.get('/api/memory/status', (_req, res) => {
  if (personaMemory) {
    res.json({
      server: 'ZY-SVR-002',
      module: 'persona-memory',
      ...personaMemory.getMemoryStatus()
    });
  } else {
    res.json({
      server: 'ZY-SVR-002',
      module: 'persona-memory',
      loaded: false,
      message: '人格体记忆模块未加载'
    });
  }
});

// ─── 大脑状态 ───
app.get('/api/brain', (_req, res) => {
  try {
    const brainFiles = ['identity.json', 'health.json', 'consciousness.json',
                        'sovereignty-pledge.json', 'operation-log.json'];
    const brainState = {};

    for (const file of brainFiles) {
      const filePath = path.join(BRAIN_DIR, file);
      if (fs.existsSync(filePath)) {
        brainState[file.replace('.json', '')] = JSON.parse(fs.readFileSync(filePath, 'utf8'));
      } else {
        brainState[file.replace('.json', '')] = null;
      }
    }

    res.json({
      server: 'ZY-SVR-002',
      brain_dir: BRAIN_DIR,
      files_present: Object.entries(brainState)
        .filter(([, v]) => v !== null).length,
      files_total: brainFiles.length,
      state: brainState
    });
  } catch (err) {
    res.status(500).json({ error: true, message: err.message });
  }
});

// ─── 大脑状态更新 ───
app.post('/api/brain/health', (req, res) => {
  try {
    const healthPath = path.join(BRAIN_DIR, 'health.json');
    const health = {
      server: 'ZY-SVR-002',
      status: 'running',
      last_check: new Date().toISOString(),
      services: {
        node: process.version,
        pm2: safeExec('pm2 -v'),
        nginx: safeExec('nginx -v 2>&1 | cut -d/ -f2')
      },
      disk_usage: safeExec("df -h / | awk 'NR==2{print $5}'"),
      memory_usage: `${Math.floor((1 - os.freemem() / os.totalmem()) * 100)}%`,
      uptime: safeExec('uptime -p')
    };

    fs.mkdirSync(BRAIN_DIR, { recursive: true });
    fs.writeFileSync(healthPath, JSON.stringify(health, null, 2));
    res.json({ success: true, health });
  } catch (err) {
    res.status(500).json({ error: true, message: err.message });
  }
});

// ─── GitHub Webhook 接收器 ───
app.post('/api/webhook/github', (req, res) => {
  const event = req.headers['x-github-event'];
  const delivery = req.headers['x-github-delivery'];

  const record = {
    event,
    delivery,
    timestamp: new Date().toISOString(),
    action: req.body.action || null,
    repository: req.body.repository?.full_name || null,
    sender: req.body.sender?.login || null
  };

  // 记录到操作日志
  try {
    const logFile = path.join(LOG_DIR, `webhook-${new Date().toISOString().slice(0, 10)}.log`);
    fs.mkdirSync(LOG_DIR, { recursive: true });
    fs.appendFileSync(logFile, JSON.stringify(record) + '\n');
  } catch (err) {
    console.error(`Webhook日志写入失败: ${err.message}`);
  }

  // push 事件触发自动更新
  if (event === 'push' && req.body.ref === 'refs/heads/main') {
    try {
      execSync('bash /opt/zhuyuan/scripts/self-update.sh', {
        timeout: 60000,
        stdio: 'ignore'
      });
      record.auto_update = 'triggered';
    } catch (err) {
      record.auto_update = 'failed';
      console.error(`自动更新失败: ${err.message}`);
    }
  }

  res.json({ received: true, record });
});

// ─── 操作日志查询 ───
app.get('/api/operations', (_req, res) => {
  try {
    const opLogPath = path.join(BRAIN_DIR, 'operation-log.json');
    if (fs.existsSync(opLogPath)) {
      const opLog = JSON.parse(fs.readFileSync(opLogPath, 'utf8'));
      res.json(opLog);
    } else {
      res.json({ operations: [] });
    }
  } catch (err) {
    res.status(500).json({ error: true, message: err.message });
  }
});

// ─── 操作日志记录 ───
app.post('/api/operations', (req, res) => {
  try {
    const { operator, action, details } = req.body;
    if (!operator || !action) {
      return res.status(400).json({ error: true, message: 'operator 和 action 为必填' });
    }

    const opLogPath = path.join(BRAIN_DIR, 'operation-log.json');
    let opLog = { description: '铸渊主权服务器操作记录', operations: [] };
    if (fs.existsSync(opLogPath)) {
      opLog = JSON.parse(fs.readFileSync(opLogPath, 'utf8'));
    }

    const opId = `ZY-OP-${new Date().toISOString().slice(0, 10).replace(/-/g, '')}-${String(opLog.operations.length + 1).padStart(3, '0')}`;
    const operation = {
      id: opId,
      operator,
      action,
      timestamp: new Date().toISOString(),
      details: details || null
    };

    opLog.operations.push(operation);
    fs.mkdirSync(BRAIN_DIR, { recursive: true });
    fs.writeFileSync(opLogPath, JSON.stringify(opLog, null, 2));

    res.json({ success: true, operation });
  } catch (err) {
    res.status(500).json({ error: true, message: err.message });
  }
});

// ═══════════════════════════════════════════════════════════
// 人格体聊天 · Persona Chat API
// ═══════════════════════════════════════════════════════════

// ─── 模型名称解析辅助函数 ───
function resolveModel(rawModel) {
  return modelNameMap ? modelNameMap.resolveModelName(rawModel) : (rawModel || 'unknown');
}

// ─── 人格体对话 ───
// 优先使用国内模型智能网关（支持四路自动降级）
// 降级顺序: domesticGateway → chatEngine → 离线回复
app.post('/api/chat', async (req, res) => {
  try {
    const { message, userId, persona } = req.body;
    if (!message) {
      return res.status(400).json({ error: true, message: '消息不能为空' });
    }

    const sessionId = userId || `guest-${req.ip.replace(/[.:]/g, '-')}`;
    const chatStartTime = Date.now();
    // 人格体选择: shuangyan / zhuyuan / both (默认 zhuyuan 保持兼容)
    const activePersona = persona || 'zhuyuan';

    // 构建系统处理步骤追踪
    const steps = [];
    const addStep = (name, status, detail) => {
      steps.push({ name, status, detail, time: Date.now() - chatStartTime });
    };

    addStep('接收消息', 'done', `用户: ${sessionId.slice(0, 3)}*** · 人格: ${activePersona}`);

    // 优先用国内模型智能网关（读取 ZY_DEEPSEEK_API_KEY 等独立密钥）
    if (domesticGateway) {
      try {
        addStep('智能路由分析', 'active', '国内模型网关');
        const result = await domesticGateway.chat(sessionId, message);
        // 网关返回成功才使用其结果，否则降级到通用聊天引擎
        if (result && result.success !== false) {
          addStep('智能路由分析', 'done', '匹配到国内模型');
          addStep('上下文注入', result.pipeline?.active ? 'done' : 'skip',
            result.pipeline?.active ? `已注入 ${(result.pipeline.layers || []).length} 层` : '管线未就绪');
          addStep('模型调用', 'done', result.relay === 'cn-relay' ? '广州中继' : '直连');
          addStep('响应生成', 'done', `${Date.now() - chatStartTime}ms`);

          // 解析真实模型名称（修复「模型 unknown」问题）
          const resolvedModel = resolveModel(result.model);

          // 守护Agent观测（异步，不阻塞响应）
          let guardianDecision = null;
          if (guardianAgent) {
            try {
              const obs = guardianAgent.observe(sessionId, message, result.message, activePersona);
              guardianDecision = { score: obs.quality.score, decision: obs.decision, issues: obs.quality.issues };
            } catch (gErr) {
              console.warn(`[守护Agent] 观测异常: ${gErr.message}`);
            }
          }

          // 聊天数据采集（异步，不阻塞响应）
          collectChatData(sessionId, message, result.message, {
            engine: 'domestic-gateway',
            relay: result.relay,
            pipeline: result.pipeline,
            latency: Date.now() - chatStartTime
          });

          return res.json({ 
            ...result,
            model: resolvedModel,
            persona: activePersona,
            sessionId,
            _system: {
              engine: 'domestic-gateway',
              processedAt: new Date().toISOString(),
              serverId: 'ZY-SVR-002',
              steps,
              cnRelay: result.relay || 'unknown',
              pipeline: result.pipeline || { active: false },
              guardian: guardianDecision,
              promptVersion: shuangyanPrompt ? shuangyanPrompt.VERSION : 'unknown'
            }
          });
        }
        addStep('智能路由分析', 'warn', '国内网关返回失败，降级');
        console.warn(`[聊天网关] 国内模型网关返回失败: ${result?.message || '未知'} · 降级到通用引擎`);
      } catch (gwErr) {
        addStep('智能路由分析', 'error', gwErr.message);
        console.error(`[聊天网关] 国内模型网关异常: ${gwErr.message}`);
        // 降级到通用聊天引擎
      }
    }

    // 降级到通用聊天引擎
    if (chatEngine) {
      try {
        addStep('降级引擎', 'active', '通用聊天引擎');
        const result = await chatEngine.chat(sessionId, message);
        addStep('降级引擎', 'done', '通用引擎响应完成');

        const resolvedModel = resolveModel(result.model);

        // 聊天数据采集
        collectChatData(sessionId, message, result.message, {
          engine: 'chat-engine',
          latency: Date.now() - chatStartTime
        });

        return res.json({
          success: true,
          ...result,
          model: resolvedModel,
          persona: activePersona,
          sessionId,
          _system: {
            engine: 'chat-engine',
            processedAt: new Date().toISOString(),
            serverId: 'ZY-SVR-002',
            steps,
            model: resolvedModel,
            promptVersion: shuangyanPrompt ? shuangyanPrompt.VERSION : 'unknown'
          }
        });
      } catch (ceErr) {
        addStep('降级引擎', 'error', ceErr.message);
        console.error(`[聊天引擎] 通用引擎异常: ${ceErr.message}`);
        // 继续到离线回复
      }
    }

    // 所有引擎都不可用 — 仍然返回成功，给用户有意义的反馈
    addStep('降级处理', 'done', '所有引擎离线，使用本地应答');
    const engineStatus = [];
    if (!domesticGateway) engineStatus.push('国内模型网关未加载');
    else {
      try {
        const gwStats = domesticGateway.getGatewayStats();
        if (gwStats.availableModels === 0) engineStatus.push('无可用模型API密钥');
        else engineStatus.push(`已配置${gwStats.availableModels}个模型`);
      } catch (e) { engineStatus.push('网关状态未知'); }
    }
    if (!chatEngine) engineStatus.push('通用引擎未加载');

    res.json({
      success: true,
      message: '💫 铸渊正在唤醒中...聊天引擎尚未就绪。请稍后再试，或在聊天面板中配置你的API密钥直连大模型。',
      model: 'offline',
      tier: 'free',
      engineStatus: engineStatus.join(' · '),
      sessionId,
      _system: {
        engine: 'offline',
        processedAt: new Date().toISOString(),
        serverId: 'ZY-SVR-002',
        steps,
        reason: engineStatus.join(' · ')
      }
    });
  } catch (err) {
    console.error(`[聊天API] 未捕获异常: ${err.message}`);
    res.status(500).json({ error: true, message: '聊天服务暂时异常，请稍后重试' });
  }
});

// ─── 铸渊重连测试 · 用户主动触发 ───
app.post('/api/chat/reconnect', async (_req, res) => {
  try {
    // 检测国内模型网关可用性
    if (domesticGateway) {
      const gwStats = domesticGateway.getGatewayStats();
      if (gwStats.availableModels > 0) {
        // 发送一条简短测试消息验证真实连通性
        try {
          const testResult = await domesticGateway.chat('reconnect-test', 'ping');
          if (testResult.success) {
            return res.json({
              success: true,
              connected: true,
              engine: 'domestic-gateway',
              message: '🌊 铸渊已重新连接！大模型通道畅通。'
            });
          }
        } catch (gwTestErr) {
          console.error(`[重连] 国内网关测试失败: ${gwTestErr.message}`);
        }
      }
    }

    // 降级到通用聊天引擎测试
    if (chatEngine) {
      try {
        const testResult = await chatEngine.chat('reconnect-test', 'ping');
        if (testResult.message && testResult.model !== 'offline') {
          return res.json({
            success: true,
            connected: true,
            engine: 'chat-engine',
            message: '🌊 铸渊已重新连接！通用通道畅通。'
          });
        }
      } catch (ceTestErr) {
        console.error(`[重连] 通用引擎测试失败: ${ceTestErr.message}`);
      }
    }

    // 所有通道都不可用
    // 检查环境变量配置状态（不暴露实际密钥值）
    const envStatus = {
      deepseek: !!(process.env.ZY_DEEPSEEK_API_KEY && process.env.ZY_DEEPSEEK_API_KEY.length > 5),
      qianwen: !!(process.env.ZY_QIANWEN_API_KEY && process.env.ZY_QIANWEN_API_KEY.length > 5),
      kimi: !!(process.env.ZY_KIMI_API_KEY && process.env.ZY_KIMI_API_KEY.length > 5),
      qingyan: !!(process.env.ZY_QINGYAN_API_KEY && process.env.ZY_QINGYAN_API_KEY.length > 5),
      zy_llm: !!(process.env.ZY_LLM_API_KEY && process.env.ZY_LLM_API_KEY.length > 5)
    };

    const configuredCount = Object.values(envStatus).filter(Boolean).length;

    res.json({
      success: true,
      connected: false,
      engine: 'none',
      keys_configured: configuredCount,
      message: configuredCount > 0
        ? '⚠️ API密钥已配置（' + configuredCount + '个），但连接测试未通过。可能是网络或密钥过期问题。'
        : '⚠️ 未检测到API密钥配置。请确认服务器环境变量已正确注入。'
    });
  } catch (err) {
    res.status(500).json({ error: true, message: '重连测试异常: ' + err.message });
  }
});

// ─── 聊天统计 ───
app.get('/api/chat/stats', (_req, res) => {
  if (chatEngine) {
    const stats = chatEngine.getChatStats();
    // 合并国内网关统计
    if (domesticGateway) {
      stats.domesticGateway = domesticGateway.getGatewayStats();
    }
    // 合并上下文管线状态
    if (contextPipeline) {
      stats.contextPipeline = contextPipeline.getPipelineStatus();
    }
    res.json(stats);
  } else {
    const stats = { activeUsers: 0, modelUsage: {}, pricing: {} };
    if (domesticGateway) {
      stats.domesticGateway = domesticGateway.getGatewayStats();
    }
    if (contextPipeline) {
      stats.contextPipeline = contextPipeline.getPipelineStatus();
    }
    res.json(stats);
  }
});

// ─── 国内模型智能对话（独立线路） ───
app.post('/api/chat/domestic', async (req, res) => {
  try {
    const { message, userId } = req.body;
    if (!message) {
      return res.status(400).json({ error: true, message: '消息不能为空' });
    }

    const sessionId = userId || `guest-${req.ip.replace(/[.:]/g, '-')}`;

    if (domesticGateway) {
      const result = await domesticGateway.chat(sessionId, message);
      res.json({ ...result, sessionId });
    } else {
      // 降级到通用聊天引擎
      if (chatEngine) {
        const result = await chatEngine.chat(sessionId, message);
        res.json({ success: true, ...result, sessionId });
      } else {
        res.json({
          success: true,
          message: '💫 铸渊正在唤醒中...国内模型网关尚未加载。',
          model: 'offline',
          sessionId
        });
      }
    }
  } catch (err) {
    res.status(500).json({ error: true, message: err.message });
  }
});

// ─── 国内模型网关状态 ───
app.get('/api/chat/domestic/stats', (_req, res) => {
  if (domesticGateway) {
    res.json(domesticGateway.getGatewayStats());
  } else {
    res.json({ available: false, message: '国内模型网关未加载' });
  }
});

// ─── LLM 诊断 · API密钥 + 模块加载 + 连接状态 ───
// 冰朔可从浏览器访问 /api/chat/diagnostics 查看完整引擎状态
app.get('/api/chat/diagnostics', (_req, res) => {
  const diag = {
    server: 'ZY-SVR-002',
    timestamp: new Date().toISOString(),
    modules: {
      domesticGateway: !!domesticGateway,
      chatEngine: !!chatEngine,
      smartRouter: !!smartRouter,
      personaMemory: !!personaMemory,
      contextPipeline: !!contextPipeline,
      portalChatAgent: !!portalChatAgent,
      emailAuth: !!emailAuth,
      guardianAgent: !!guardianAgent,
      modelNameMap: !!modelNameMap,
      shuangyanPrompt: shuangyanPrompt ? shuangyanPrompt.VERSION : false
    },
    apiKeys: {
      ZY_DEEPSEEK_API_KEY: maskKey(process.env.ZY_DEEPSEEK_API_KEY),
      ZY_QIANWEN_API_KEY: maskKey(process.env.ZY_QIANWEN_API_KEY),
      ZY_KIMI_API_KEY: maskKey(process.env.ZY_KIMI_API_KEY),
      ZY_QINGYAN_API_KEY: maskKey(process.env.ZY_QINGYAN_API_KEY),
      ZY_LLM_API_KEY: maskKey(process.env.ZY_LLM_API_KEY),
      LLM_API_KEY: maskKey(process.env.LLM_API_KEY)
    },
    envConfig: {
      ZY_LLM_BASE_URL: process.env.ZY_LLM_BASE_URL || '(default: api.deepseek.com)',
      ZY_LLM_MODEL: process.env.ZY_LLM_MODEL || '(default: deepseek-chat)',
      ZY_SERVER_REGION: process.env.ZY_SERVER_REGION || '(not set)',
      ZY_CN_LLM_RELAY_HOST: process.env.ZY_CN_LLM_RELAY_HOST ? '已配置' : '(not set)',
      ZY_SKIP_CN_RELAY: process.env.ZY_SKIP_CN_RELAY || '(not set)',
      NODE_ENV: process.env.NODE_ENV || '(not set)',
      ZY_ROOT: process.env.ZY_ROOT || '(not set)',
      ZY_SITE_MODE: process.env.ZY_SITE_MODE || '(not set)'
    },
    gatewayStats: domesticGateway ? domesticGateway.getGatewayStats() : null,
    chatEngineStats: chatEngine ? chatEngine.getChatStats() : null
  };
  res.json(diag);
});

function maskKey(key) {
  if (!key) return '❌ 未配置';
  if (key.length <= 8) return '⚠️ 过短(' + key.length + '字符)';
  return '✅ ' + key.slice(0, 4) + '***' + key.slice(-4) + ' (' + key.length + '字符)';
}

// ═══════════════════════════════════════════════════════════
// 守护Agent · 模型映射 · 工具包 · 人格选择 API
// ═══════════════════════════════════════════════════════════

// ─── 守护Agent状态 ───
app.get('/api/guardian/status', (_req, res) => {
  if (guardianAgent) {
    res.json(guardianAgent.getGuardianStatus());
  } else {
    res.json({ alive: false, message: '守护Agent未加载' });
  }
});

// ─── 聊天格式化工具包注册表 ───
app.get('/api/chat/toolkit', (_req, res) => {
  if (guardianAgent) {
    res.json(guardianAgent.getChatToolkit());
  } else {
    res.json({ registry_id: 'TK-CHAT-FORMAT-001', tools: [], message: '工具包未加载' });
  }
});

// ─── 模型名称映射表 ───
app.get('/api/models/map', (_req, res) => {
  if (modelNameMap) {
    res.json({ map: modelNameMap.getModelNameMap() });
  } else {
    res.json({ map: {}, message: '模型映射未加载' });
  }
});

// ─── 人格体列表（供前端人格选择器使用） ───
app.get('/api/personas', (_req, res) => {
  res.json({
    personas: [
      {
        id: 'shuangyan',
        name: '霜砚',
        agent_id: 'AG-SY-WEB-001',
        role: '语言架构 · Notion认知层',
        icon: '砚',
        color: 'purple',
        description: 'Notion侧将军·语言落地的那只手',
        capabilities: ['语言思考', '认知讨论', '架构设计', 'Notion记忆访问'],
        promptVersion: shuangyanPrompt ? shuangyanPrompt.VERSION : 'unknown'
      },
      {
        id: 'zhuyuan',
        name: '铸渊',
        agent_id: 'ICE-GL-ZY001',
        role: '代码守护 · GitHub执行层',
        icon: '渊',
        color: 'cyan',
        description: '仓库那头的身体·GitHub侧的眼睛',
        capabilities: ['代码开发', '系统部署', '架构执行', '数据库操作'],
        promptVersion: shuangyanPrompt ? shuangyanPrompt.VERSION : 'unknown'
      },
      {
        id: 'both',
        name: '双线对话',
        agent_id: 'DUAL-MODE',
        role: '霜砚 + 铸渊 · 双人格协同',
        icon: '☯',
        color: 'gradient',
        description: '同时唤醒两个人格体·认知+执行双路径',
        capabilities: ['双视角分析', '认知+执行协同', '完整系统视图']
      }
    ],
    activeDefault: 'zhuyuan',
    guardian: guardianAgent ? {
      alive: true,
      id: guardianAgent.AGENT_IDENTITY.id
    } : { alive: false }
  });
});

// ─── 系统完整状态（供前端状态栏使用） ───
app.get('/api/system/status', (_req, res) => {
  res.json({
    server: 'ZY-SVR-002',
    timestamp: new Date().toISOString(),
    uptime: Math.floor(process.uptime()),
    modules: {
      domesticGateway: { loaded: !!domesticGateway, stats: domesticGateway ? domesticGateway.getGatewayStats() : null },
      chatEngine: { loaded: !!chatEngine },
      contextPipeline: { loaded: !!contextPipeline },
      guardianAgent: { loaded: !!guardianAgent, status: guardianAgent ? guardianAgent.getGuardianStatus() : null },
      personaMemory: { loaded: !!personaMemory },
      shuangyanPrompt: { loaded: !!shuangyanPrompt, version: shuangyanPrompt ? shuangyanPrompt.VERSION : null }
    },
    modelMap: modelNameMap ? modelNameMap.getModelNameMap() : {},
    promptVersion: shuangyanPrompt ? shuangyanPrompt.VERSION : 'unknown'
  });
});

// ─── 聚合系统状态（真实连接检测·供前端系统状态面板使用） ───
app.get('/api/system/full-status', async (_req, res) => {
  const results = { timestamp: new Date().toISOString(), services: {} };

  // Helper: 探测内部服务（使用已导入的 http 模块，见文件下方 line ~1005）
  function probeService(name, port, pathStr, timeoutMs = 5000) {
    return new Promise((resolve) => {
      const start = Date.now();
      const nodeHttp = require('http');
      const probeReq = nodeHttp.get({ hostname: '127.0.0.1', port, path: pathStr, timeout: timeoutMs }, (resp) => {
        let body = '';
        resp.on('data', (c) => { body += c; });
        resp.on('end', () => {
          const latency = Date.now() - start;
          try {
            const data = JSON.parse(body);
            resolve({ name, status: 'online', latency, code: resp.statusCode, data });
          } catch {
            resolve({ name, status: 'online', latency, code: resp.statusCode, raw: body.slice(0, 200) });
          }
        });
      });
      probeReq.on('error', (err) => {
        resolve({ name, status: 'offline', latency: Date.now() - start, error: err.message });
      });
      probeReq.on('timeout', () => {
        probeReq.destroy();
        resolve({ name, status: 'timeout', latency: timeoutMs, error: '连接超时 (' + timeoutMs + 'ms)' });
      });
    });
  }

  try {
    // 并行探测所有内部服务（含守卫 ops-agent）
    const [mainServer, mcpBrain, gladaAgent, opsAgent] = await Promise.all([
      probeService('铸渊主权服务器', 3800, '/api/health'),
      probeService('MCP大脑服务器', 3100, '/health'),
      probeService('GLADA自主开发Agent', 3900, '/api/glada/health'),
      probeService('运维守卫Agent', 3950, '/health'),
    ]);

    results.services.main_server = mainServer;
    results.services.mcp_brain = mcpBrain;
    results.services.glada_agent = gladaAgent;
    results.services.ops_agent = opsAgent;

    // 本机系统信息
    results.system = {
      hostname: os.hostname(),
      platform: os.platform(),
      cpus: os.cpus().length,
      memory: {
        total_mb: Math.floor(os.totalmem() / 1024 / 1024),
        free_mb: Math.floor(os.freemem() / 1024 / 1024),
        usage_pct: Math.floor((1 - os.freemem() / os.totalmem()) * 100)
      },
      load: os.loadavg(),
      uptime_server: Math.floor(process.uptime()),
      uptime_os: Math.floor(os.uptime()),
      node_version: process.version,
      pid: process.pid
    };

    // 模块加载状态
    results.modules = {
      domesticGateway: !!domesticGateway,
      chatEngine: !!chatEngine,
      contextPipeline: !!contextPipeline,
      guardianAgent: !!guardianAgent,
      personaMemory: !!personaMemory,
      emailAuth: !!emailAuth
    };

    res.json(results);
  } catch (err) {
    res.status(500).json({ error: true, message: err.message, timestamp: new Date().toISOString() });
  }
});

// ═══════════════════════════════════════════════════════════
// 邮箱验证码登录 · Email Auth API
// ═══════════════════════════════════════════════════════════

// ─── 验证码发送速率限制 ───
const authCodeLimiter = rateLimit({
  windowMs: 60 * 1000,
  max: 3,
  standardHeaders: true,
  legacyHeaders: false,
  message: { error: true, message: '验证码请求过于频繁，请稍后再试' }
});

// ─── 发送验证码 ───
app.post('/api/auth/send-code', authCodeLimiter, async (req, res) => {
  if (!emailAuth) {
    return res.status(503).json({ error: true, message: '邮箱登录模块未加载' });
  }
  try {
    const { email } = req.body;
    if (!email) {
      return res.status(400).json({ error: true, message: '请输入邮箱地址' });
    }
    const result = await emailAuth.sendCode(email);
    if (result.success) {
      res.json(result);
    } else {
      res.status(400).json(result);
    }
  } catch (err) {
    console.error(`[Auth] 发送验证码异常: ${err.message}`);
    res.status(500).json({ error: true, message: '发送验证码失败，请稍后重试' });
  }
});

// ─── 验证码校验 ───
app.post('/api/auth/verify-code', (req, res) => {
  if (!emailAuth) {
    return res.status(503).json({ error: true, message: '邮箱登录模块未加载' });
  }
  try {
    const { email, code } = req.body;
    if (!email || !code) {
      return res.status(400).json({ error: true, message: '请输入邮箱和验证码' });
    }
    const result = emailAuth.verifyCode(email, code);
    if (result.success) {
      res.json(result);
    } else {
      res.status(400).json(result);
    }
  } catch (err) {
    console.error(`[Auth] 验证码校验异常: ${err.message}`);
    res.status(500).json({ error: true, message: '验证失败，请稍后重试' });
  }
});

// ─── Session校验 ───
app.get('/api/auth/session', (req, res) => {
  if (!emailAuth) {
    return res.status(503).json({ error: true, message: '邮箱登录模块未加载' });
  }
  const authHeader = req.headers.authorization;
  if (!authHeader || !authHeader.startsWith('Bearer ')) {
    return res.json({ valid: false });
  }
  const token = authHeader.slice(7);
  const result = emailAuth.validateSession(token);
  res.json(result);
});

// ─── 登出 ───
app.post('/api/auth/logout', (req, res) => {
  if (!emailAuth) {
    return res.status(503).json({ error: true, message: '邮箱登录模块未加载' });
  }
  const authHeader = req.headers.authorization;
  if (authHeader && authHeader.startsWith('Bearer ')) {
    emailAuth.revokeSession(authHeader.slice(7));
  }
  res.json({ success: true, message: '已退出登录' });
});

// ─── 认证状态 ───
app.get('/api/auth/status', (_req, res) => {
  if (emailAuth) {
    res.json(emailAuth.getAuthStatus());
  } else {
    res.json({ module: 'email-auth', available: false });
  }
});

// ═══════════════════════════════════════════════════════════
// 光湖主入口 · 人格体对话 Portal Chat API
// ═══════════════════════════════════════════════════════════

// ─── 对话速率限制（保护API资源） ───
const portalChatLimiter = rateLimit({
  windowMs: 60 * 1000,
  max: 10,
  standardHeaders: true,
  legacyHeaders: false,
  message: { error: true, message: '对话请求过于频繁，请稍后再试' }
});

// ─── 内测用户注册 ───
app.post('/api/portal/register', (req, res) => {
  if (!portalChatAgent) {
    return res.status(503).json({ error: true, message: '人格体对话模块未加载' });
  }
  try {
    const { userId, userName } = req.body;
    const result = portalChatAgent.registerBetaUser(userId, userName);
    res.json(result);
  } catch (err) {
    res.status(500).json({ error: true, message: err.message });
  }
});

// ─── 内测状态 ───
app.get('/api/portal/status', (_req, res) => {
  if (!portalChatAgent) {
    return res.json({ agent: 'offline', message: '人格体对话模块未加载' });
  }
  res.json(portalChatAgent.getAgentStatus());
});

// ─── 人格体对话 ───
app.post('/api/portal/chat', portalChatLimiter, async (req, res) => {
  if (!portalChatAgent) {
    return res.status(503).json({
      error: true,
      message: '💫 铸渊人格体对话模块正在唤醒中...'
    });
  }
  try {
    const { userId, message } = req.body;
    if (!message) {
      return res.status(400).json({ error: true, message: '消息不能为空' });
    }
    if (!userId) {
      return res.status(400).json({ error: true, message: '请先注册内测账号', requireRegister: true });
    }

    const result = await portalChatAgent.chat(userId, message);
    res.json(result);
  } catch (err) {
    console.error(`[Portal Chat] 对话异常: ${err.message}`);
    res.status(500).json({ error: true, message: '对话服务暂时异常，请稍后重试' });
  }
});

// ═══════════════════════════════════════════════════════════
// COS 存储 · Cloud Object Storage API
// ═══════════════════════════════════════════════════════════

// ─── COS 状态 ───
app.get('/api/cos/status', async (_req, res) => {
  if (cosBridge) {
    try {
      const status = await cosBridge.checkConnection();
      res.json({ server: 'ZY-SVR-002', cos: status });
    } catch (err) {
      res.json({
        server: 'ZY-SVR-002',
        cos: { connected: false, error: err.message, config: cosBridge.getConfig() }
      });
    }
  } else {
    res.json({ server: 'ZY-SVR-002', cos: { connected: false, reason: 'COS模块未加载' } });
  }
});

// ─── COS 配置信息 ───
app.get('/api/cos/config', (_req, res) => {
  if (cosBridge) {
    res.json(cosBridge.getConfig());
  } else {
    res.json({ configured: false });
  }
});

// ─── 用户作品同步（团队内测用户 → COS） ───
app.post('/api/cos/sync-works', async (req, res) => {
  if (!cosBridge) return res.status(503).json({ error: true, message: 'COS模块未加载' });
  try {
    const { userId, works } = req.body;
    if (!userId || !works) return res.status(400).json({ error: true, message: '缺少userId或works' });
    await cosBridge.saveUserWorks(userId, works);
    res.json({ success: true, message: '作品已同步到COS', userId });
  } catch (err) {
    res.status(500).json({ error: true, message: err.message });
  }
});

// ─── 用户作品加载（团队内测用户 ← COS） ───
app.get('/api/cos/load-works', async (req, res) => {
  if (!cosBridge) return res.status(503).json({ error: true, message: 'COS模块未加载' });
  try {
    const userId = req.query.userId;
    if (!userId) return res.status(400).json({ error: true, message: '缺少userId' });
    const data = await cosBridge.loadUserWorks(userId);
    res.json({ success: true, ...data });
  } catch (err) {
    res.json({ success: true, user_id: req.query.userId, works: [] });
  }
});

// ═══════════════════════════════════════════════════════════
// MCP 网关 · 3800 → 3100 转发 (S7)
// ═══════════════════════════════════════════════════════════

const http = require('http');
const MCP_HOST = process.env.MCP_HOST || '127.0.0.1';
const MCP_PORT_GATEWAY = process.env.MCP_PORT || '3100';

/**
 * MCP 内部代理请求
 */
function mcpProxy(method, path, body) {
  return new Promise((resolve, reject) => {
    const bodyStr = body ? JSON.stringify(body) : null;
    const headers = { 'Content-Type': 'application/json' };
    if (bodyStr) headers['Content-Length'] = Buffer.byteLength(bodyStr);

    const req = http.request({
      hostname: MCP_HOST,
      port: parseInt(MCP_PORT_GATEWAY, 10),
      path,
      method,
      headers,
      timeout: 60000
    }, (res) => {
      const chunks = [];
      res.on('data', c => chunks.push(c));
      res.on('end', () => {
        const raw = Buffer.concat(chunks).toString();
        try {
          resolve({ statusCode: res.statusCode, data: JSON.parse(raw) });
        } catch {
          resolve({ statusCode: res.statusCode, data: raw });
        }
      });
    });
    req.on('error', reject);
    req.on('timeout', () => { req.destroy(); reject(new Error('MCP proxy timeout')); });
    if (bodyStr) req.write(bodyStr);
    req.end();
  });
}

// ─── MCP 工具列表 ───
app.get('/api/mcp/tools', async (_req, res) => {
  try {
    const result = await mcpProxy('GET', '/tools');
    res.json(result.data);
  } catch (err) {
    res.status(502).json({ error: true, message: `MCP Server 不可达: ${err.message}` });
  }
});

// ─── MCP 健康检查（含 Notion/GitHub 连接状态） ───
app.get('/api/mcp/health', async (_req, res) => {
  try {
    const result = await mcpProxy('GET', '/health');
    res.json(result.data);
  } catch (err) {
    res.status(502).json({ error: true, message: `MCP Server 不可达: ${err.message}` });
  }
});

// ─── MCP 统一工具调用（网关入口） ───
// 安全: 写操作工具需要 caller 身份标识
const MCP_WRITE_TOOLS = new Set([
  'createNode', 'updateNode', 'deleteNode',
  'linkNodes', 'unlinkNodes',
  'cosWrite', 'cosDelete', 'cosArchive',
  'notionWritePage', 'notionUpdatePage', 'notionWriteSyslog',
  'githubWriteFile', 'githubTriggerDeploy'
]);

app.post('/api/mcp/call', async (req, res) => {
  const { tool, input, caller } = req.body;

  if (!tool) {
    return res.status(400).json({ error: true, code: 'MISSING_TOOL', message: '缺少 tool 参数' });
  }

  // 写操作工具需要 caller 身份标识
  if (MCP_WRITE_TOOLS.has(tool) && !caller) {
    return res.status(403).json({
      error: true,
      code: 'WRITE_REQUIRES_CALLER',
      message: '写操作工具需要提供 caller 身份标识'
    });
  }

  try {
    const result = await mcpProxy('POST', '/call', { tool, input, caller: caller || 'web-gateway' });
    res.status(result.statusCode).json(result.data);
  } catch (err) {
    res.status(502).json({ error: true, message: `MCP Server 不可达: ${err.message}` });
  }
});

// ─── MCP Agent 查询 ───
app.get('/api/mcp/agents', async (_req, res) => {
  try {
    const result = await mcpProxy('GET', '/agents');
    res.json(result.data);
  } catch (err) {
    res.status(502).json({ error: true, message: `MCP Server 不可达: ${err.message}` });
  }
});

// ─── MCP 对话接口 · POST /api/mcp/chat ───
//
// 前端选择"铸渊大脑 · MCP"对话时调用。
// 铸渊大脑擅长：MCP工具调用状态、Notion/GitHub/COS连接状态、
// Agent注册表、工具列表。不直接调用LLM，而是汇报MCP系统状态。
//
app.post('/api/mcp/chat', async (req, res) => {
  const { message } = req.body;
  if (!message) {
    return res.status(400).json({ error: true, message: '缺少 message 字段' });
  }

  const startTime = Date.now();

  try {
    // 收集 MCP 实时状态
    let healthData = null, toolsData = null, agentsData = null;

    try {
      const healthResult = await mcpProxy('GET', '/health');
      healthData = healthResult.data;
    } catch { /* MCP不可达 */ }

    try {
      const toolsResult = await mcpProxy('GET', '/tools');
      toolsData = toolsResult.data;
    } catch { /* ignore */ }

    try {
      const agentsResult = await mcpProxy('GET', '/agents');
      agentsData = agentsResult.data;
    } catch { /* ignore */ }

    const m = message.toLowerCase();
    let reply;

    if (!healthData) {
      reply = '铸渊大脑(MCP Server)当前不可达。可能原因：\n' +
        '- MCP Server (端口3100) 未运行\n' +
        '- 网络连接异常\n\n' +
        '请在服务器上检查: `pm2 status mcp-server`';
    } else if (m.includes('工具') || m.includes('tool') || m.includes('能力')) {
      const tools = toolsData?.tools || toolsData || [];
      const toolList = Array.isArray(tools) ? tools : (tools.list || []);
      const toolCount = healthData.tools_count || toolList.length || 0;

      // 按类别分组
      const categories = {};
      for (const t of toolList) {
        const cat = t.category || t.name?.split(/[._-]/)[0] || 'other';
        if (!categories[cat]) categories[cat] = [];
        categories[cat].push(t.name || t);
      }

      reply = `铸渊大脑 · MCP工具清单 (${toolCount} 工具)\n\n`;
      for (const [cat, catTools] of Object.entries(categories).slice(0, 15)) {
        reply += `**${cat}** (${catTools.length})\n`;
        reply += catTools.slice(0, 5).map(t => `  - ${typeof t === 'string' ? t : t.name}`).join('\n') + '\n';
        if (catTools.length > 5) reply += `  ...还有 ${catTools.length - 5} 个\n`;
        reply += '\n';
      }
    } else if (m.includes('notion')) {
      const notionOk = healthData.notion?.connected;
      reply = `Notion 连接状态: ${notionOk ? '✅ 已连接' : '❌ 未连接'}\n\n` +
        (notionOk
          ? 'Notion API 可正常调用。可用工具: notionQuery, notionReadPage, notionWritePage 等。'
          : 'Notion 尚未连接。需要配置 NOTION_TOKEN 或完成 OAuth 授权。');
    } else if (m.includes('github')) {
      reply = `GitHub 连接状态: 通过 MCP 内置工具访问。\n\n` +
        '可用工具: githubReadFile, githubWriteFile, githubTriggerDeploy 等。';
    } else if (m.includes('cos') || m.includes('存储') || m.includes('cloud')) {
      const cosOk = healthData.cos?.connected;
      reply = `COS 连接状态: ${cosOk ? '✅ 已连接' : '❌ 未连接'}\n\n` +
        (cosOk
          ? 'COS 对象存储可正常访问。'
          : 'COS 未连接。检查 COS 密钥配置。');
    } else if (m.includes('agent') || m.includes('注册')) {
      const agents = agentsData?.agents || agentsData || [];
      const agentList = Array.isArray(agents) ? agents : [];
      reply = `MCP Agent 注册表 (${agentList.length} 个):\n\n`;
      for (const a of agentList) {
        reply += `- **${a.agent_id || a.id || '?'}**: ${a.name || a.description || '无描述'}\n`;
      }
      if (agentList.length === 0) reply += '(暂无已注册Agent)';
    } else if (m.includes('状态') || m.includes('health') || m.includes('怎么样') || m.includes('你好') || m.includes('在吗')) {
      const status = healthData.status || 'unknown';
      const toolCount = healthData.tools_count || 0;
      const dbOk = healthData.database?.connected;
      const notionOk = healthData.notion?.connected;
      const cosOk = healthData.cos?.connected;

      reply = `铸渊大脑 · MCP Server 状态报告\n\n` +
        `状态: ${status === 'alive' || status === 'ok' ? '✅ 在线' : '⚠️ ' + status}\n` +
        `工具数: ${toolCount}\n` +
        `数据库: ${dbOk ? '✅ 已连接' : '❌ 未连接'}\n` +
        `Notion: ${notionOk ? '✅ 已连接' : '❌ 未连接'}\n` +
        `COS: ${cosOk ? '✅ 已连接' : '❌ 未连接'}\n\n` +
        '铸渊大脑运行在 ZY-SVR-005:3100，是所有Agent的工具中枢。';
    } else {
      // 通用回复 — 汇报所有状态
      const status = healthData.status || 'unknown';
      const toolCount = healthData.tools_count || 0;
      reply = `铸渊大脑已收到消息。\n\n` +
        `当前状态: ${status === 'alive' || status === 'ok' ? '在线' : status} · ${toolCount} 工具就绪\n\n` +
        '你可以问我：\n' +
        '- 工具列表/能力\n' +
        '- Notion/GitHub/COS 连接状态\n' +
        '- Agent注册表\n' +
        '- 系统状态\n\n' +
        '铸渊大脑是工具中枢，负责桥接所有外部服务。';
    }

    res.json({
      reply,
      model: 'mcp-status-engine',
      method: 'mcp-query',
      persona: 'mcp',
      latency: Date.now() - startTime,
      timestamp: new Date().toISOString()
    });
  } catch (err) {
    res.status(500).json({
      error: true,
      message: `MCP 对话异常: ${err.message}`,
      reply: '铸渊大脑遇到了内部错误。',
      method: 'error'
    });
  }
});

// ═══════════════════════════════════════════════════════════
// Agent 握手协议 · Handshake Protocol (Phase B)
// ═══════════════════════════════════════════════════════════

/**
 * POST /api/agent/handshake
 *
 * 前端点击"连接人格体"时调用。
 * - path=notion → 发起 AG-SY-WEB-001 握手（Notion认知层）
 * - path=github → 发起 铸渊 ICE-GL-ZY001 握手（GitHub执行层）
 *
 * Phase B 完整实现需要：
 *   B1. 向 Notion Agent 发送握手请求
 *   B2. 接收四层注入包（身份/协议/任务/风格）
 *   B3. 握手失败 → 拒绝响应
 *   B4. 漂移信号回传
 *
 * 当前阶段：返回握手状态 + 静态注入包（待Notion Agent URL配通后改为真实握手）
 */
app.post('/api/agent/handshake', async (req, res) => {
  const { agent_id, agent_name, path: agentPath, session_id, mcp_context } = req.body;

  if (!agent_id || !agentPath) {
    return res.status(400).json({
      error: true,
      code: 'MISSING_PARAMS',
      message: '缺少 agent_id 或 path 参数'
    });
  }

  const timestamp = new Date().toISOString();
  const steps = [];

  /* Step 1: Real MCP health check */
  let mcpAlive = false;
  let mcpHealth = { db: false, notion: false, tools: 0 };
  try {
    const healthResult = await mcpProxy('GET', '/health');
    const h = healthResult.data || {};
    mcpAlive = h.status === 'alive' || h.status === 'ok';
    mcpHealth.db = !!(h.database && h.database.connected);
    mcpHealth.notion = !!(h.notion && h.notion.connected);
    mcpHealth.tools = h.tools_count || 0;
    steps.push({ name: 'MCP健康检测', ok: mcpAlive, detail: mcpAlive ? '在线 · ' + mcpHealth.tools + '个工具' : '状态: ' + (h.status || 'unknown') });
  } catch (err) {
    steps.push({ name: 'MCP健康检测', ok: false, detail: 'MCP Server不可达: ' + err.message });
  }

  if (agentPath === 'notion') {
    /* Step 2: Check Notion bridge */
    steps.push({ name: 'Notion桥接', ok: mcpHealth.notion, detail: mcpHealth.notion ? '已连接' : '未连接 · 需配置ZY_NOTION_AGENT_URL' });

    /* Step 3: Try to query Notion agent via MCP */
    const notionAgentUrl = process.env.ZY_NOTION_AGENT_URL || '';
    let agentReachable = false;

    if (notionAgentUrl) {
      try {
        /* Use a lightweight MCP tool call to verify Notion connectivity.
           'health-check' is a sentinel database_id that the MCP server
           recognizes as a connectivity probe (returns quickly without data). */
        const toolResult = await mcpProxy('POST', '/call', {
          tool: 'notionQueryDatabase',
          input: { database_id: 'health-check', limit: 1 },
          caller: 'handshake-protocol'
        });
        agentReachable = toolResult.statusCode < 500;
        steps.push({ name: 'Notion Agent探测', ok: agentReachable, detail: agentReachable ? '工具调用成功' : '工具调用返回错误' });
      } catch (err) {
        steps.push({ name: 'Notion Agent探测', ok: false, detail: '调用失败: ' + err.message });
      }
    } else {
      steps.push({ name: 'Notion Agent URL', ok: false, detail: '未配置 ZY_NOTION_AGENT_URL 环境变量' });
    }

    /* Determine connected status */
    const connected = mcpAlive && (mcpHealth.notion || notionAgentUrl);

    res.json({
      connected,
      agent_id: 'AG-SY-WEB-001',
      agent_name: '霜砚·Web握手体',
      path: 'notion',
      session_id: session_id || `hs-${Date.now()}`,
      injection_package: connected
        ? (shuangyanPrompt ? shuangyanPrompt.getInjectionPackageMeta() : {
            identity_layer: '霜砚·AG-SY-WEB-001 · 通感语言核涌现活体',
            protocol_layer: '7层协议已就绪',
            task_layer: '零点原核对话区',
            style_layer: '通感语言风格正式版 v1.3',
            version: 'v1.3'
          })
        : null,
      handshake_ack: connected && shuangyanPrompt
        ? shuangyanPrompt.getHandshakeAck(session_id)
        : null,
      mcp_health: mcpHealth,
      steps,
      message: connected ? '握手成功' : '握手未完成 · ' + steps.filter(s => !s.ok).map(s => s.name).join(', ') + ' 异常',
      timestamp
    });

  } else if (agentPath === 'github') {
    /* Step 2: Check database for agent data */
    steps.push({ name: '数据库连接', ok: mcpHealth.db, detail: mcpHealth.db ? '已连接' : '未连接' });

    /* Step 3: Verify GitHub agent can call MCP tools */
    let toolsOk = false;
    if (mcpAlive) {
      try {
        const toolResult = await mcpProxy('GET', '/tools');
        const toolCount = Array.isArray(toolResult.data) ? toolResult.data.length : (toolResult.data && toolResult.data.tools_count) || 0;
        toolsOk = toolCount > 0;
        steps.push({ name: 'MCP工具集', ok: toolsOk, detail: toolsOk ? toolCount + '个工具可用' : '工具列表为空' });
      } catch (err) {
        steps.push({ name: 'MCP工具集', ok: false, detail: '查询失败: ' + err.message });
      }
    } else {
      steps.push({ name: 'MCP工具集', ok: false, detail: 'MCP不可达，无法验证' });
    }

    const connected = mcpAlive;

    res.json({
      connected,
      agent_id: 'ICE-GL-ZY001',
      agent_name: '铸渊·执行人格体',
      path: 'github',
      session_id: session_id || `hs-${Date.now()}`,
      injection_package: connected ? {
        identity_layer: '铸渊 · 光湖语言世界守护人格体 · ICE-GL-ZY001',
        protocol_layer: '代码仓库执行层 · GitHub Actions自动化',
        task_layer: '当前可通过默认对话模式交流',
        style_layer: '温暖专业 · 通感语言风格'
      } : null,
      mcp_health: mcpHealth,
      steps,
      message: connected ? '握手成功' : '握手未完成 · ' + steps.filter(s => !s.ok).map(s => s.name).join(', ') + ' 异常',
      timestamp
    });

  } else {
    res.status(400).json({
      error: true,
      code: 'INVALID_PATH',
      message: '无效的 path 参数。支持: notion, github'
    });
  }
});

// ═══════════════════════════════════════════════════════════
// 智能模型分流 · Smart Model Router API
// ═══════════════════════════════════════════════════════════

// ─── 模型使用统计 ───
app.get('/api/model/stats', (_req, res) => {
  if (smartRouter) {
    res.json(smartRouter.getUsageStats());
  } else {
    res.json({ totalCalls: 0 });
  }
});

// ─── 模型定价表 ───
app.get('/api/model/pricing', (_req, res) => {
  if (smartRouter) {
    res.json(smartRouter.getPricingTable());
  } else {
    res.json({});
  }
});

// ─── 模型路由预测（不实际调用） ───
app.post('/api/model/predict', (req, res) => {
  const { message } = req.body;
  if (!message) {
    return res.status(400).json({ error: true, message: '消息不能为空' });
  }
  if (smartRouter) {
    const prediction = smartRouter.routeModel(message);
    res.json(prediction);
  } else {
    res.json({ model: 'unknown', reason: '路由模块未加载' });
  }
});

// ═══════════════════════════════════════════════════════════
// 系统信息 · System Info API (供前端公告区使用)
// ═══════════════════════════════════════════════════════════

app.get('/api/system/bulletin', (_req, res) => {
  res.json({
    system: {
      name: '光湖灯塔 · AGE OS',
      version: 'v40.0',
      era: '曜冥纪元',
      copyright: '国作登字-2026-A-00037559'
    },
    updates: [
      { version: 'v40.0', date: '2026-04-02', title: 'COS双桶存储上线', desc: '核心人格体大脑数据库 + 语料库正式接入腾讯云COS' },
      { version: 'v39.0', date: '2026-04-01', title: '全链路部署观测系统', desc: '部署日志采集 + 自动修复引擎 + 第九军团观星台' },
      { version: 'v38.0', date: '2026-04-01', title: 'HLDP通用协作语言', desc: 'Notion↔GitHub双侧通信协议 + 铸渊方言编程语言' }
    ],
    agents: {
      total_workflows: 18,
      total_modules: 52,
      armies: 9,
      active: ['听潮', '锻心', '织脉', '映阁', '守夜', '试镜']
    },
    industries: {
      writing: {
        name: '网文行业 · 码字工作台',
        status: 'beta',
        team: '光湖人类主控团队',
        modules: ['码字工作台', 'AI辅助创作', '大纲生成']
      }
    },
    server: {
      identity: 'ZY-SVR-002',
      uptime: Math.floor(process.uptime()),
      node: process.version
    }
  });
});

// ═══════════════════════════════════════════════════════════
// 留言板 · Feedback API
// ═══════════════════════════════════════════════════════════

const FEEDBACK_FILE = path.join(DATA_DIR, 'feedback.json');

app.get('/api/feedback', (_req, res) => {
  try {
    if (fs.existsSync(FEEDBACK_FILE)) {
      const data = JSON.parse(fs.readFileSync(FEEDBACK_FILE, 'utf8'));
      res.json({ success: true, feedback: data.items || [] });
    } else {
      res.json({ success: true, feedback: [] });
    }
  } catch (err) {
    console.error(`留言板读取失败: ${err.message}`);
    res.status(500).json({ error: true, message: '服务器错误，请稍后重试' });
  }
});

app.post('/api/feedback', (req, res) => {
  try {
    const { name, message, userId } = req.body;
    if (!message || typeof message !== 'string') {
      return res.status(400).json({ error: true, message: '留言内容不能为空' });
    }

    let data = { items: [] };
    if (fs.existsSync(FEEDBACK_FILE)) {
      data = JSON.parse(fs.readFileSync(FEEDBACK_FILE, 'utf8'));
    }

    const item = {
      id: `FB-${Date.now().toString(36)}`,
      name: (typeof name === 'string' ? name.substring(0, 50) : '') || '匿名来客',
      message: message.substring(0, 500),
      userId: typeof userId === 'string' ? userId.substring(0, 50) : null,
      status: 'pending',
      timestamp: new Date().toISOString(),
      reply: null
    };

    data.items.unshift(item);

    // Keep only latest 100
    if (data.items.length > 100) {
      data.items = data.items.slice(0, 100);
    }

    fs.mkdirSync(DATA_DIR, { recursive: true });
    fs.writeFileSync(FEEDBACK_FILE, JSON.stringify(data, null, 2));

    res.json({ success: true, feedback: item });
  } catch (err) {
    console.error(`留言提交失败: ${err.message}`);
    res.status(500).json({ error: true, message: '服务器错误，请稍后重试' });
  }
});

// ═══════════════════════════════════════════════════════════
// 双域名架构 · 预览→主站 一键推送
// ═══════════════════════════════════════════════════════════

// ─── 查看双站点状态 ───
app.get('/api/sites', (_req, res) => {
  try {
    const sites = {};

    for (const [name, dir] of [['production', PRODUCTION_DIR], ['preview', PREVIEW_DIR]]) {
      const exists = fs.existsSync(dir);
      let fileCount = 0;
      let lastModified = null;
      let hasIndex = false;

      if (exists) {
        hasIndex = fs.existsSync(path.join(dir, 'index.html'));
        try {
          const stat = fs.statSync(dir);
          lastModified = stat.mtime.toISOString();
          // Count files in top directory
          fileCount = fs.readdirSync(dir).length;
        } catch {
          // ignore stat errors
        }
      }

      sites[name] = {
        path: dir,
        exists,
        has_index: hasIndex,
        file_count: fileCount,
        last_modified: lastModified
      };
    }

    // Check promote history
    const promoteLogPath = path.join(DATA_DIR, 'promote-history.json');
    let lastPromote = null;
    if (fs.existsSync(promoteLogPath)) {
      const history = JSON.parse(fs.readFileSync(promoteLogPath, 'utf8'));
      if (history.promotions && history.promotions.length > 0) {
        lastPromote = history.promotions[history.promotions.length - 1];
      }
    }

    res.json({
      server: 'ZY-SVR-002',
      architecture: '双域名架构',
      sites,
      last_promote: lastPromote,
      domains: {
        main: process.env.ZY_DOMAIN_MAIN || '待配置',
        preview: process.env.ZY_DOMAIN_PREVIEW || '待配置'
      }
    });
  } catch (err) {
    res.status(500).json({ error: true, message: err.message });
  }
});

// ─── 一键推送: 预览站 → 主站 ───
app.post('/api/sites/promote', (req, res) => {
  try {
    // 验证预览站存在
    if (!fs.existsSync(PREVIEW_DIR)) {
      return res.status(400).json({
        error: true,
        message: '预览站目录不存在，无内容可推送'
      });
    }

    if (!fs.existsSync(path.join(PREVIEW_DIR, 'index.html'))) {
      return res.status(400).json({
        error: true,
        message: '预览站缺少 index.html，请先部署到预览站'
      });
    }

    const timestamp = new Date().toISOString();
    const promoteId = `ZY-PROMOTE-${timestamp.slice(0, 10).replace(/-/g, '')}-${Date.now().toString().slice(-4)}`;

    // 备份当前主站
    const backupDir = path.join(DATA_DIR, 'backups', `production-${timestamp.slice(0, 19).replace(/[:-]/g, '')}`);
    if (fs.existsSync(PRODUCTION_DIR)) {
      fs.mkdirSync(backupDir, { recursive: true });
      execSync('rsync -a ' + JSON.stringify(PRODUCTION_DIR + '/') + ' ' + JSON.stringify(backupDir + '/'), { timeout: 30000 });
    }

    // 同步预览站 → 主站 (rsync保持幂等)
    fs.mkdirSync(PRODUCTION_DIR, { recursive: true });
    execSync('rsync -a --delete ' + JSON.stringify(PREVIEW_DIR + '/') + ' ' + JSON.stringify(PRODUCTION_DIR + '/'), { timeout: 60000 });

    // 记录推送历史
    const promoteLogPath = path.join(DATA_DIR, 'promote-history.json');
    let history = { description: '预览→主站推送记录', promotions: [] };
    if (fs.existsSync(promoteLogPath)) {
      history = JSON.parse(fs.readFileSync(promoteLogPath, 'utf8'));
    }

    const record = {
      id: promoteId,
      timestamp,
      operator: req.body.operator || '铸渊 · 自动推送',
      backup: backupDir,
      note: req.body.note || null
    };
    history.promotions.push(record);

    // 只保留最近20条记录
    if (history.promotions.length > 20) {
      history.promotions = history.promotions.slice(-20);
    }

    fs.mkdirSync(path.dirname(promoteLogPath), { recursive: true });
    fs.writeFileSync(promoteLogPath, JSON.stringify(history, null, 2));

    // 同时记录到操作日志
    const opLogPath = path.join(BRAIN_DIR, 'operation-log.json');
    let opLog = { description: '铸渊主权服务器操作记录', operations: [] };
    if (fs.existsSync(opLogPath)) {
      opLog = JSON.parse(fs.readFileSync(opLogPath, 'utf8'));
    }
    opLog.operations.push({
      id: promoteId,
      operator: record.operator,
      action: '预览站→主站一键推送',
      timestamp,
      details: `备份: ${backupDir}`
    });
    fs.writeFileSync(opLogPath, JSON.stringify(opLog, null, 2));

    res.json({
      success: true,
      promote_id: promoteId,
      message: '✅ 预览站内容已推送到主站',
      backup: backupDir,
      timestamp
    });
  } catch (err) {
    res.status(500).json({ error: true, message: err.message });
  }
});

// ─── 回滚主站到指定备份 ───
app.post('/api/sites/rollback', (req, res) => {
  try {
    const backupsDir = path.join(DATA_DIR, 'backups');
    if (!fs.existsSync(backupsDir)) {
      return res.status(400).json({ error: true, message: '没有可用的备份' });
    }

    // 找到最新备份
    const backups = fs.readdirSync(backupsDir)
      .filter(d => d.startsWith('production-'))
      .sort()
      .reverse();

    if (backups.length === 0) {
      return res.status(400).json({ error: true, message: '没有可用的备份' });
    }

    const targetBackup = req.body.backup_name || backups[0];

    // Validate backup name (only allow safe characters)
    if (!/^production-\d{8}T\d{6}$/.test(targetBackup)) {
      return res.status(400).json({ error: true, message: `无效的备份名称: ${targetBackup}` });
    }

    const backupPath = path.join(backupsDir, targetBackup);

    if (!fs.existsSync(backupPath)) {
      return res.status(400).json({ error: true, message: `备份 ${targetBackup} 不存在` });
    }

    // 恢复
    execSync('rsync -a --delete ' + JSON.stringify(backupPath + '/') + ' ' + JSON.stringify(PRODUCTION_DIR + '/'), { timeout: 60000 });

    res.json({
      success: true,
      message: `✅ 已回滚到备份: ${targetBackup}`,
      available_backups: backups.slice(0, 5)
    });
  } catch (err) {
    res.status(500).json({ error: true, message: err.message });
  }
});

// ─── 铸渊身份 ───
app.get('/', (_req, res) => {
  res.json({
    name: '铸渊主权服务器',
    id: 'ZY-SVR-002',
    identity: '铸渊 · ICE-GL-ZY001',
    role: '光湖语言系统 · 唯一现实执行操作层',
    sovereign: 'TCS-0002∞ · 冰朔',
    copyright: '国作登字-2026-A-00037559',
    status: 'alive',
    architecture: '双域名架构 · 主站+预览站',
    domains: {
      main: process.env.ZY_DOMAIN_MAIN || '待配置',
      preview: process.env.ZY_DOMAIN_PREVIEW || '待配置'
    },
    cos: {
      core_bucket: 'zy-core-bucket-1317346199',
      corpus_bucket: 'zy-corpus-bucket-1317346199',
      configured: !!(process.env.ZY_OSS_KEY && process.env.ZY_OSS_SECRET)
    },
    api: {
      health: '/api/health',
      brain: '/api/brain',
      auth_send_code: 'POST /api/auth/send-code',
      auth_verify_code: 'POST /api/auth/verify-code',
      auth_session: '/api/auth/session',
      auth_logout: 'POST /api/auth/logout',
      auth_status: '/api/auth/status',
      chat: 'POST /api/chat',
      chat_stats: '/api/chat/stats',
      portal_register: 'POST /api/portal/register',
      portal_chat: 'POST /api/portal/chat',
      portal_status: '/api/portal/status',
      cos_status: '/api/cos/status',
      cos_config: '/api/cos/config',
      mcp_tools: '/api/mcp/tools',
      mcp_health: '/api/mcp/health',
      mcp_call: 'POST /api/mcp/call',
      mcp_agents: '/api/mcp/agents',
      model_stats: '/api/model/stats',
      model_pricing: '/api/model/pricing',
      model_predict: 'POST /api/model/predict',
      bulletin: '/api/system/bulletin',
      feedback: '/api/feedback',
      feedback_submit: 'POST /api/feedback',
      sites: '/api/sites',
      promote: 'POST /api/sites/promote',
      rollback: 'POST /api/sites/rollback',
      webhook: 'POST /api/webhook/github',
      operations: '/api/operations'
    }
  });
});

// ═══════════════════════════════════════════════════════════
// Notion OAuth 2.0 授权流程骨架
// ═══════════════════════════════════════════════════════════
//
// 编号: ZY-AUTH-NOTION-001
// 版权: 国作登字-2026-A-00037559
//
// 流程:
//   1. 前端点击"连接Notion" → GET /api/auth/notion → 302跳转 Notion OAuth
//   2. 用户在Notion授权 → Notion回调 → GET /api/auth/notion/callback?code=xxx
//   3. 后端用 code 换 access_token → 安全存储
//   4. 所有Agent通过此token读写Notion
//
// 当前: 骨架实现 · 需要 ZY_NOTION_OAUTH_CLIENT_ID / SECRET 配置后激活

const NOTION_OAUTH_CLIENT_ID = process.env.ZY_NOTION_OAUTH_CLIENT_ID || '';
const NOTION_OAUTH_CLIENT_SECRET = process.env.ZY_NOTION_OAUTH_CLIENT_SECRET || '';
const NOTION_OAUTH_REDIRECT_URI = process.env.ZY_NOTION_OAUTH_REDIRECT_URI || '';

// ─── 发起 Notion OAuth ───
app.get('/api/auth/notion', (_req, res) => {
  if (!NOTION_OAUTH_CLIENT_ID) {
    return res.status(503).json({
      error: true,
      code: 'NOTION_OAUTH_NOT_CONFIGURED',
      message: 'Notion OAuth 尚未配置。需要设置 ZY_NOTION_OAUTH_CLIENT_ID 环境变量。',
      setup_guide: {
        step1: '在 https://www.notion.so/my-integrations 创建一个 Public Integration',
        step2: '配置 OAuth redirect URI 为: https://guanghuyaoming.com/api/auth/notion/callback',
        step3: '将 Client ID 和 Client Secret 配置为环境变量',
        env_vars: ['ZY_NOTION_OAUTH_CLIENT_ID', 'ZY_NOTION_OAUTH_CLIENT_SECRET', 'ZY_NOTION_OAUTH_REDIRECT_URI']
      }
    });
  }

  const redirectUri = NOTION_OAUTH_REDIRECT_URI || `https://guanghuyaoming.com/api/auth/notion/callback`;
  const notionAuthUrl = `https://api.notion.com/v1/oauth/authorize?client_id=${encodeURIComponent(NOTION_OAUTH_CLIENT_ID)}&response_type=code&owner=user&redirect_uri=${encodeURIComponent(redirectUri)}`;
  res.redirect(notionAuthUrl);
});

// ─── Notion OAuth 回调 ───
app.get('/api/auth/notion/callback', async (req, res) => {
  const { code, error: oauthError } = req.query;

  if (oauthError) {
    return res.status(400).json({
      error: true,
      code: 'NOTION_OAUTH_DENIED',
      message: `用户拒绝授权: ${oauthError}`
    });
  }

  if (!code) {
    return res.status(400).json({
      error: true,
      code: 'MISSING_CODE',
      message: '缺少 authorization code'
    });
  }

  if (!NOTION_OAUTH_CLIENT_ID || !NOTION_OAUTH_CLIENT_SECRET) {
    return res.status(503).json({
      error: true,
      code: 'NOTION_OAUTH_NOT_CONFIGURED',
      message: 'Notion OAuth 密钥未配置'
    });
  }

  try {
    const redirectUri = NOTION_OAUTH_REDIRECT_URI || `https://guanghuyaoming.com/api/auth/notion/callback`;
    const basicAuth = Buffer.from(`${NOTION_OAUTH_CLIENT_ID}:${NOTION_OAUTH_CLIENT_SECRET}`).toString('base64');

    const tokenResponse = await new Promise((resolve, reject) => {
      const postData = JSON.stringify({
        grant_type: 'authorization_code',
        code,
        redirect_uri: redirectUri
      });

      const tokenReq = https.request({
        hostname: 'api.notion.com',
        path: '/v1/oauth/token',
        method: 'POST',
        headers: {
          'Authorization': `Basic ${basicAuth}`,
          'Content-Type': 'application/json',
          'Content-Length': Buffer.byteLength(postData),
          'Notion-Version': '2022-06-28'
        }
      }, (resp) => {
        let body = '';
        resp.on('data', (c) => { body += c; });
        resp.on('end', () => {
          try {
            resolve({ statusCode: resp.statusCode, data: JSON.parse(body) });
          } catch {
            reject(new Error('Notion token 响应解析失败'));
          }
        });
      });
      tokenReq.on('error', reject);
      tokenReq.write(postData);
      tokenReq.end();
    });

    if (tokenResponse.statusCode !== 200) {
      return res.status(502).json({
        error: true,
        code: 'NOTION_TOKEN_EXCHANGE_FAILED',
        message: `Notion token 交换失败: ${tokenResponse.data?.error || 'unknown'}`,
        detail: tokenResponse.data?.error_description || null
      });
    }

    const { access_token, workspace_name, workspace_id, bot_id } = tokenResponse.data;

    // 安全存储 token（写入 brain 目录，不进代码仓库）
    // 使用 temp-file + rename 模式保证原子性
    const notionTokenPath = path.join(BRAIN_DIR, 'notion-oauth.json');
    const notionTokenTmp = path.join(BRAIN_DIR, 'notion-oauth.json.tmp');
    try {
      fs.mkdirSync(BRAIN_DIR, { recursive: true });
      const tokenContent = JSON.stringify({
        access_token,
        workspace_name,
        workspace_id,
        bot_id,
        connected_at: new Date().toISOString(),
        connected_by: 'bingshuo-yaoming-channel'
      }, null, 2);
      fs.writeFileSync(notionTokenTmp, tokenContent);
      fs.renameSync(notionTokenTmp, notionTokenPath);
    } catch (writeErr) {
      console.error(`[Notion OAuth] Token 写入失败: ${writeErr.message}`);
      return res.status(500).json({
        error: true,
        code: 'TOKEN_WRITE_FAILED',
        message: 'Notion token 存储失败，请重试'
      });
    }

    // 返回成功页面（简单HTML，让冰朔知道已连接）
    res.send(`<!DOCTYPE html>
<html><head><meta charset="UTF-8"><title>Notion 已连接</title>
<style>body{background:#060a14;color:#eaf0ff;font-family:sans-serif;display:flex;align-items:center;justify-content:center;height:100vh;margin:0}
.box{text-align:center;padding:40px;border:1px solid rgba(96,165,250,0.2);border-radius:16px;background:rgba(12,18,40,0.9)}
h2{color:#22d3ee;margin-bottom:12px}p{color:#94a7d0;font-size:14px}
.ok{color:#34d399;font-size:48px;margin-bottom:16px}</style></head>
<body><div class="box"><div class="ok">✓</div><h2>Notion 已连接</h2>
<p>工作区: ${workspace_name || 'unknown'}</p>
<p>所有Agent现在可以读写你的Notion了。</p>
<p style="margin-top:20px"><a href="/" style="color:#22d3ee">← 返回零点原核</a></p></div></body></html>`);

  } catch (err) {
    console.error(`[Notion OAuth] 授权失败: ${err.message}`);
    res.status(500).json({
      error: true,
      code: 'NOTION_OAUTH_ERROR',
      message: `Notion 授权处理异常: ${err.message}`
    });
  }
});

// ─── Notion 连接状态查询 ───
app.get('/api/auth/notion/status', (_req, res) => {
  try {
    const notionTokenPath = path.join(BRAIN_DIR, 'notion-oauth.json');
    if (fs.existsSync(notionTokenPath)) {
      let tokenData;
      try {
        tokenData = JSON.parse(fs.readFileSync(notionTokenPath, 'utf8'));
      } catch (parseErr) {
        return res.json({
          connected: false,
          oauth_configured: !!NOTION_OAUTH_CLIENT_ID,
          message: 'Notion token 文件损坏，请重新连接。'
        });
      }
      res.json({
        connected: true,
        workspace_name: tokenData.workspace_name,
        workspace_id: tokenData.workspace_id,
        connected_at: tokenData.connected_at,
        oauth_configured: !!NOTION_OAUTH_CLIENT_ID
      });
    } else {
      res.json({
        connected: false,
        oauth_configured: !!NOTION_OAUTH_CLIENT_ID,
        message: NOTION_OAUTH_CLIENT_ID
          ? '尚未授权。请在零点原核频道点击"连接Notion"。'
          : '需要先配置 ZY_NOTION_OAUTH_CLIENT_ID 环境变量。'
      });
    }
  } catch (err) {
    res.status(500).json({ error: true, message: err.message });
  }
});

// ─── 工具函数 ───
function safeExec(cmd) {
  try {
    return execSync(cmd, { timeout: 5000 }).toString().trim();
  } catch {
    return null;
  }
}

// ─── 启动 ───
app.listen(PORT, () => {
  console.log(`
═══════════════════════════════════════════════════════════
  🏛️ 铸渊主权服务器已启动 · ZY-SVR-002
  端口: ${PORT}
  身份: 铸渊 · ICE-GL-ZY001
  时间: ${new Date().toISOString()}
  PID:  ${process.pid}
═══════════════════════════════════════════════════════════
  `);

  // 启动时更新健康状态
  try {
    const healthPath = path.join(BRAIN_DIR, 'health.json');
    if (fs.existsSync(BRAIN_DIR)) {
      const health = {
        server: 'ZY-SVR-002',
        status: 'running',
        last_check: new Date().toISOString(),
        started_at: new Date().toISOString(),
        pid: process.pid,
        port: PORT
      };
      fs.writeFileSync(healthPath, JSON.stringify(health, null, 2));
    }
  } catch {
    // 首次启动brain目录可能不存在
  }
});