1052 lines
36 KiB
JavaScript
1052 lines
36 KiB
JavaScript
#!/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 { 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}`);
|
||
}
|
||
|
||
// ═══════════════════════════════════════════════════════════
|
||
// API 路由
|
||
// ═══════════════════════════════════════════════════════════
|
||
|
||
// ─── 健康检查 ───
|
||
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
|
||
// ═══════════════════════════════════════════════════════════
|
||
|
||
// ─── 人格体对话 ───
|
||
// 优先使用国内模型智能网关（支持四路自动降级）
|
||
// 降级顺序: domesticGateway → chatEngine → 离线回复
|
||
app.post('/api/chat', 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, '-')}`;
|
||
|
||
// 优先用国内模型智能网关（读取 ZY_DEEPSEEK_API_KEY 等独立密钥）
|
||
if (domesticGateway) {
|
||
try {
|
||
const result = await domesticGateway.chat(sessionId, message);
|
||
// 网关返回成功才使用其结果，否则降级到通用聊天引擎
|
||
if (result && result.success !== false) {
|
||
return res.json({ ...result, sessionId });
|
||
}
|
||
console.warn(`[聊天网关] 国内模型网关返回失败: ${result?.message || '未知'} · 降级到通用引擎`);
|
||
} catch (gwErr) {
|
||
console.error(`[聊天网关] 国内模型网关异常: ${gwErr.message}`);
|
||
// 降级到通用聊天引擎
|
||
}
|
||
}
|
||
|
||
// 降级到通用聊天引擎
|
||
if (chatEngine) {
|
||
try {
|
||
const result = await chatEngine.chat(sessionId, message);
|
||
return res.json({
|
||
success: true,
|
||
...result,
|
||
sessionId
|
||
});
|
||
} catch (ceErr) {
|
||
console.error(`[聊天引擎] 通用引擎异常: ${ceErr.message}`);
|
||
// 继续到离线回复
|
||
}
|
||
}
|
||
|
||
// 所有引擎都不可用 — 仍然返回成功，给用户有意义的反馈
|
||
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
|
||
});
|
||
} 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();
|
||
}
|
||
res.json(stats);
|
||
} else {
|
||
const stats = { activeUsers: 0, modelUsage: {}, pricing: {} };
|
||
if (domesticGateway) {
|
||
stats.domesticGateway = domesticGateway.getGatewayStats();
|
||
}
|
||
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: '国内模型网关未加载' });
|
||
}
|
||
});
|
||
|
||
// ═══════════════════════════════════════════════════════════
|
||
// 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}` });
|
||
}
|
||
});
|
||
|
||
// ═══════════════════════════════════════════════════════════
|
||
// 智能模型分流 · 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',
|
||
chat: 'POST /api/chat',
|
||
chat_stats: '/api/chat/stats',
|
||
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'
|
||
}
|
||
});
|
||
});
|
||
|
||
// ─── 工具函数 ───
|
||
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目录可能不存在
|
||
}
|
||
});
|