Spaces:

xrunx
/

webhost

Paused

webhost / index.js

Upload 6 files

4554352 verified over 1 year ago

20.3 kB

const os = require('os');
const http = require('http');
const net = require('net');
const { exec, execSync } = require('child_process');

function ensureModule(name) {
    try {
        require.resolve(name);
    } catch (e) {
        console.log(`Module '${name}' not found. Installing...`);
        execSync(`npm install ${name}`, { stdio: 'inherit' });
    }
}

ensureModule('axios');
ensureModule('ws');

const axios = require('axios');
const { WebSocketServer, createWebSocketStream } = require('ws');

// 环境变量配置 - 适配Huggingface部署
const NEZHA_SERVER = process.env.NEZHA_SERVER || '';
const NEZHA_PORT = process.env.NEZHA_PORT || '';
const NEZHA_KEY = process.env.NEZHA_KEY || '';
const NAME = process.env.NAME || os.hostname();

// Vless配置
const UUID = process.env.UUID || 'e6542600-b09f-4dac-be5d-1c32fca89901';
const DOMAIN = process.env.DOMAIN || 'huggingface.chinax.site'; // 用户需要设置的域名

// 性能配置
const LOG_FLAG = process.env.LOG_FLAG === 'true' || false; // 默认关闭详细日志
const MAX_CONNECTIONS = parseInt(process.env.MAX_CONNECTIONS) || 100000; // 最大并发连接数
const SOCKET_TIMEOUT = parseInt(process.env.SOCKET_TIMEOUT) || 100000; // 连接超时时间

// Huggingface固定端口7860
const port = 7860;
const uuid = UUID;
const uuidNoHyphens = uuid.replace(/-/g, '');

console.log("~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~");
console.log("一键无交互Vless代理脚本 - Huggingface版");
console.log("当前版本：1.0.0 Huggingface适配版");
console.log("~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~");

let apiData = [];
let lastUpdateTime = new Date().toLocaleString();

// 统计信息
let connectionStats = {
    totalConnections: 0,
    activeConnections: 0,
    totalDataTransferred: 0,
    startTime: new Date()
};

// 内置节点列表 - 来自原始app.js
const builtinNodes = [
    // Cloudflare IP地址
    { domain: "104.16.0.0", name: `Vl-ws-tls-${NAME}` },
    { domain: "104.17.0.0", name: `Vl-ws-tls-${NAME}` },
    { domain: "104.18.0.0", name: `Vl-ws-tls-${NAME}` },
    { domain: "104.19.0.0", name: `Vl-ws-tls-${NAME}` },
    { domain: "104.20.0.0", name: `Vl-ws-tls-${NAME}` },
    { domain: "104.21.0.0", name: `Vl-ws-tls-${NAME}` },
    { domain: "104.22.0.0", name: `Vl-ws-tls-${NAME}` },
    { domain: "104.24.0.0", name: `Vl-ws-tls-${NAME}` },
    { domain: "104.25.0.0", name: `Vl-ws-tls-${NAME}` },
    { domain: "104.26.0.0", name: `Vl-ws-tls-${NAME}` },
    { domain: "104.27.0.0", name: `Vl-ws-tls-${NAME}` },
    // 官方优选
    { domain: "cf.090227.xyz", name: "三网自适应分流官方优选" },
    { domain: "ct.090227.xyz", name: "电信官方优选" },
    { domain: "cmcc.090227.xyz", name: "移动官方优选" },
    // 官方域名优选
    { domain: "shopify.com", name: "优选官方域名-shopify" },
    { domain: "time.is", name: "优选官方域名-time" },
    { domain: "icook.hk", name: "优选官方域名-icook.hk" },
    { domain: "icook.tw", name: "优选官方域名-icook.tw" },
    { domain: "ip.sb", name: "优选官方域名-ip.sb" },
    { domain: "japan.com", name: "优选官方域名-japan" },
    { domain: "malaysia.com", name: "优选官方域名-malaysia" },
    { domain: "russia.com", name: "优选官方域名-russia" },
    { domain: "singapore.com", name: "优选官方域名-singapore" },
    { domain: "skk.moe", name: "优选官方域名-skk" },
    { domain: "www.visa.com.sg", name: "优选官方域名-visa.sg" },
    { domain: "www.visa.com.hk", name: "优选官方域名-visa.hk" },
    { domain: "www.visa.com.tw", name: "优选官方域名-visa.tw" },
    { domain: "www.visa.co.jp", name: "优选官方域名-visa.jp" },
    { domain: "www.visakorea.com", name: "优选官方域名-visa.kr" },
    { domain: "www.gco.gov.qa", name: "优选官方域名-gov.qa" },
    { domain: "www.gov.se", name: "优选官方域名-gov.se" },
    { domain: "www.gov.ua", name: "优选官方域名-gov.ua" },
    // 第三方维护
    { domain: "cfip.xxxxxxxx.tk", name: "OTC提供维护官方优选" },
    { domain: "bestcf.onecf.eu.org", name: "Mingyu提供维护官方优选" },
    { domain: "cf.zhetengsha.eu.org", name: "小一提供维护官方优选" },
    { domain: "xn--b6gac.eu.org", name: "第三方维护官方优选" },
    { domain: "yx.887141.xyz", name: "第三方维护官方优选" },
    { domain: "8.889288.xyz", name: "第三方维护官方优选" },
    { domain: "cfip.1323123.xyz", name: "第三方维护官方优选" },
    { domain: "cf.515188.xyz", name: "第三方维护官方优选" },
    { domain: "cf-st.annoy.eu.org", name: "第三方维护官方优选" },
    { domain: "cf.0sm.com", name: "第三方维护官方优选" },
    { domain: "cf.877771.xyz", name: "第三方维护官方优选" },
    { domain: "cf.345673.xyz", name: "第三方维护官方优选" },
    { domain: "bestproxy.onecf.eu.org", name: "Mingyu提供维护反代优选" },
    { domain: "proxy.xxxxxxxx.tk", name: "OTC提供维护反代优选" }
];

// API配置
const apiList = [
    {
        url: 'https://ipdb.api.030101.xyz/?type=bestcf&country=true',
        namePrefix: '优选官方API(1-'
    },
    {
        url: 'https://addressesapi.090227.xyz/CloudFlareYes',
        namePrefix: '优选官方API(2-'
    },
    {
        url: 'https://addressesapi.090227.xyz/ip.164746.xyz',
        namePrefix: '优选官方API(3-'
    },
    {
        url: 'https://ipdb.api.030101.xyz/?type=bestproxy&country=true',
        namePrefix: '优选反代API(1-'
    }
];

// 获取API数据
async function fetchApiData() {
    let allResults = [];

    try {
        for (let apiIndex = 0; apiIndex < apiList.length; apiIndex++) {
            const api = apiList[apiIndex];
            console.log(`正在请求 API: ${api.url}`);

            try {
                const response = await axios.get(api.url, { timeout: 10000 });
                const data = response.data;

                if (Array.isArray(data)) {
                    const results = data.map((item, index) => ({
                        domain: item.ip || item,
                        name: `${api.namePrefix}${index + 1})`
                    }));
                    allResults = allResults.concat(results);
                } else if (typeof data === 'string') {
                    const lines = data.split('\n').filter(line => line.trim());
                    const results = lines.map((line, index) => ({
                        domain: line.trim(),
                        name: `${api.namePrefix}${index + 1})`
                    }));
                    allResults = allResults.concat(results);
                }
            } catch (error) {
                console.error(`API ${api.url} 请求失败:`, error.message);
            }
        }

        console.log(`成功获取 ${allResults.length} 个IP地址`);
        return allResults;
    } catch (error) {
        console.error('获取API数据时出错:', error);
        return [];
    }
}

// 生成Vless配置 - 按照指定格式
function generateVlessConfig(item) {
    // 确保域名格式正确
    const cleanDomain = item.domain.replace(/#.*$/, ''); // 移除可能的注释部分

    // 不进行URL编码，直接使用原始中文名称
    const nodeName = item.name;

    // 按照指定格式构造：vless://${UUID}@${item.domain}:443?encryption=none&security=tls&sni=${DOMAIN}&fp=chrome&type=ws&host=${DOMAIN}&path=%2F#${item.name}
    const vlessUrl = `vless://${UUID}@${cleanDomain}:443?encryption=none&security=tls&sni=${DOMAIN}&fp=chrome&type=ws&host=${DOMAIN}&path=%2F#${nodeName}`;
    return vlessUrl;
}

// WebSocket处理 - 使用app.js的高效流管道方式
function handleWebSocket(ws, request) {
    const clientIP = request.headers['x-forwarded-for'] || request.headers['x-real-ip'] || request.connection.remoteAddress;
    const userAgent = request.headers['user-agent'] || 'Unknown';

    if (LOG_FLAG) {
        console.log('🔗 WebSocket连接建立:');
        console.log(`  客户端IP: ${clientIP}`);
        console.log(`  User-Agent: ${userAgent}`);
    }

    // 更新连接统计
    connectionStats.totalConnections++;
    connectionStats.activeConnections++;

    // 使用once监听第一条消息（Vless握手）
    ws.once('message', msg => {
        try {
            if (LOG_FLAG) {
                console.log(`📨 收到Vless握手消息 [${clientIP}]:`, {
                    长度: msg.length,
                    前16字节: msg.slice(0, Math.min(16, msg.length)).toString('hex')
                });
            }

            // 解析Vless协议 - 参考app.js的方式
            const [VERSION] = msg;
            const id = msg.slice(1, 17);
            const receivedUuid = id.toString('hex');

            if (LOG_FLAG) {
                console.log(`🔍 Vless协议解析 [${clientIP}]:`, {
                    版本: VERSION,
                    UUID: receivedUuid,
                    是否匹配: receivedUuid === uuidNoHyphens
                });
            }

            // 验证UUID - 使用app.js的验证方式
            if (!id.every((v, i) => v == parseInt(uuidNoHyphens.substr(i * 2, 2), 16))) {
                if (LOG_FLAG) {
                    console.log(`❌ UUID验证失败 [${clientIP}]: 期望 ${uuidNoHyphens}, 收到 ${receivedUuid}`);
                }
                ws.close(1000, 'Invalid UUID');
                return;
            }

            if (LOG_FLAG) {
                console.log(`✅ UUID验证成功 [${clientIP}]`);
            }

            // 解析目标地址 - 使用app.js的解析方式
            let i = msg.slice(17, 18).readUInt8() + 19;
            const port = msg.slice(i, i += 2).readUInt16BE(0);
            const ATYP = msg.slice(i, i += 1).readUInt8();

            let host = '';
            if (ATYP == 1) { // IPv4
                host = msg.slice(i, i += 4).join('.');
            } else if (ATYP == 2) { // 域名
                host = new TextDecoder().decode(msg.slice(i + 1, i += 1 + msg.slice(i, i + 1).readUInt8()));
            } else if (ATYP == 3) { // IPv6
                host = msg.slice(i, i += 16).reduce((s, b, i, a) => (i % 2 ? s.concat(a.slice(i - 1, i + 1)) : s), [])
                    .map(b => b.readUInt16BE(0).toString(16)).join(':');
            }

            if (LOG_FLAG) {
                console.log(`🎯 目标地址 [${clientIP}]: ${host}:${port}`);
            }

            // 发送Vless响应 - 使用app.js的方式
            ws.send(new Uint8Array([VERSION, 0]));
            if (LOG_FLAG) {
                console.log(`📤 发送Vless握手响应 [${clientIP}]`);
            }

            // 创建WebSocket流 - 使用app.js的高效方式
            const duplex = createWebSocketStream(ws);

            // 建立TCP连接并使用流管道 - 完全按照app.js的方式
            const tcpSocket = net.connect({ host, port }, function () {
                if (LOG_FLAG) {
                    console.log(`🔗 已连接到目标服务器 [${clientIP}]: ${host}:${port}`);
                }

                // 转发握手消息中的剩余数据
                if (i < msg.length) {
                    const extraData = msg.slice(i);
                    this.write(extraData);
                    connectionStats.totalDataTransferred += extraData.length;
                    if (LOG_FLAG) {
                        console.log(`📤 转发额外数据到目标服务器 [${clientIP}]: ${extraData.length} 字节`);
                    }
                }

                // 建立双向流管道 - 完全按照app.js的方式，移除日志以提高性能
                duplex.on('error', () => {}).pipe(this).on('error', () => {}).pipe(duplex);

            }).on('error', (error) => {
                if (LOG_FLAG) {
                    console.error(`❌ TCP连接错误 [${clientIP}]: ${error.message}`);
                }
                if (ws.readyState === 1) {
                    ws.close();
                }
            }).on('close', () => {
                if (LOG_FLAG) {
                    console.log(`🔌 TCP连接关闭 [${clientIP}]`);
                }
                if (ws.readyState === 1) {
                    ws.close();
                }
            });

            // 设置连接超时 - 使用配置的超时时间
            tcpSocket.setTimeout(SOCKET_TIMEOUT, () => {
                if (LOG_FLAG) {
                    console.error(`⏰ TCP连接超时 [${clientIP}]: ${host}:${port}`);
                }
                tcpSocket.destroy();
                if (ws.readyState === 1) {
                    ws.close();
                }
            });

        } catch (error) {
            if (LOG_FLAG) {
                console.error(`❌ Vless握手处理错误 [${clientIP}]:`, error);
            }
            ws.close();
        }
    }).on('error', (error) => {
        if (LOG_FLAG) {
            console.error(`❌ WebSocket错误 [${clientIP}]:`, error);
        }
        connectionStats.activeConnections--;
    }).on('close', (code, reason) => {
        if (LOG_FLAG) {
            console.log(`🔌 WebSocket连接关闭 [${clientIP}]:`, {
                代码: code,
                原因: reason?.toString() || '无'
            });
        }
        connectionStats.activeConnections--;
    });
}

// 启动Nezha监控
function startNezhaMonitoring() {
    if (NEZHA_SERVER && NEZHA_PORT && NEZHA_KEY) {
        let NEZHA_TLS = (NEZHA_PORT === '443') ? '--tls' : '';
        const command = `./server -s ${NEZHA_SERVER}:${NEZHA_PORT} -p ${NEZHA_KEY} ${NEZHA_TLS} --skip-conn --disable-auto-update --skip-procs --report-delay 4 >/dev/null 2>&1 &`;
        try {
            exec(command);
            console.log('Nezha监控已启动');
        } catch (error) {
            console.error(`Nezha监控启动错误: ${error}`);
        }
    } else {
        console.log('未配置Nezha监控，跳过启动');
    }
}

// 主函数
async function main() {
    console.log('正在获取API数据...');
    apiData = await fetchApiData();
    lastUpdateTime = new Date().toLocaleString();

    // 启动Nezha监控
    startNezhaMonitoring();

    // 创建WebSocket服务器
    const wss = new WebSocketServer({ noServer: true });

    // 创建HTTP服务器
    const server = http.createServer((req, res) => {
        const url = new URL(req.url, `http://${req.headers.host}`);
        const path = url.pathname;
        const clientIP = req.headers['x-forwarded-for'] || req.headers['x-real-ip'] || req.connection.remoteAddress;

        // 检查Base64参数
        const isBase64 = url.searchParams.has('base64') || url.searchParams.has('b64');

        // 详细的请求日志
        console.log(`\n🌐 收到HTTP请求:`);
        console.log(`  时间: ${new Date().toLocaleString()}`);
        console.log(`  客户端IP: ${clientIP}`);
        console.log(`  方法: ${req.method}`);
        console.log(`  URL: ${req.url}`);
        console.log(`  路径: ${path}`);
        console.log(`  Host: ${req.headers.host}`);
        console.log(`  User-Agent: ${req.headers['user-agent'] || 'Unknown'}`);
        console.log(`  Base64请求: ${isBase64}`);
        console.log(`  所有请求头:`, JSON.stringify(req.headers, null, 2));

        // 设置响应头，确保UTF-8编码
        const headers = {
            'Content-Type': 'text/plain; charset=utf-8',
            'Access-Control-Allow-Origin': '*',
            'Access-Control-Allow-Methods': 'GET, POST, OPTIONS',
            'Access-Control-Allow-Headers': 'Content-Type'
        };

        if (path === '/') {
            const totalNodes = builtinNodes.length + apiData.length + (DOMAIN && DOMAIN !== 'your-domain.com' ? 1 : 0);
            const uptime = Math.floor((new Date() - connectionStats.startTime) / 1000);
            const statsInfo = `Hello, World-YGkkk
内置节点数量: ${builtinNodes.length}
API获取节点数量: ${apiData.length}
总节点数量: ${totalNodes}
最后更新时间: ${lastUpdateTime}
UUID: ${uuid}
DOMAIN: ${DOMAIN}
=== 连接统计 ===
总连接数: ${connectionStats.totalConnections}
当前活跃连接: ${connectionStats.activeConnections}
总数据传输: ${(connectionStats.totalDataTransferred / 1024 / 1024).toFixed(2)} MB
运行时间: ${uptime} 秒`;

            if (LOG_FLAG) {
                console.log(`📤 返回根路径响应 [${clientIP}]:`);
                console.log(`  响应长度: ${statsInfo.length}`);
                console.log(`  总节点数: ${totalNodes}`);
                console.log(`  活跃连接: ${connectionStats.activeConnections}`);
            }

            res.writeHead(200, headers);
            res.end(statsInfo);
        } else if (path === `/${uuid}` || path === `/${uuidNoHyphens}`) {
            // 生成Vless配置列表
            let vlessConfigs = [];

            // 首先添加基本域名节点（直连）
            if (DOMAIN && DOMAIN !== 'your-domain.com') {
                const domainNode = { domain: DOMAIN, name: `直连-${NAME}` };
                vlessConfigs.push(generateVlessConfig(domainNode));
            }

            // 添加内置节点
            builtinNodes.forEach(item => {
                const config = generateVlessConfig(item);
                vlessConfigs.push(config);
            });

            // 添加API获取的节点
            apiData.forEach(item => {
                const config = generateVlessConfig(item);
                vlessConfigs.push(config);
            });

            let result = vlessConfigs.join('\n');

            if (LOG_FLAG) {
                console.log(`📤 返回配置页面响应 [${clientIP}]:`);
                console.log(`  配置数量: ${vlessConfigs.length}`);
                console.log(`  Base64编码: ${isBase64}`);
                console.log(`  原始长度: ${result.length}`);
            }

            if (isBase64) {
                // 确保Base64编码正确处理UTF-8
                result = Buffer.from(result, 'utf8').toString('base64');
                if (LOG_FLAG) {
                    console.log(`  Base64长度: ${result.length}`);
                }
            } else {
                result += '\n';
            }

            res.writeHead(200, headers);
            res.end(result);
        } else {
            res.writeHead(404, headers);
            res.end('Not Found\n');
        }
    });

    // WebSocket升级处理
    server.on('upgrade', (request, socket, head) => {
        try {
            if (LOG_FLAG) {
                console.log(`🔄 WebSocket升级请求: ${request.url}`);
            }

            // 使用ws库的WebSocketServer来处理升级
            wss.handleUpgrade(request, socket, head, (ws) => {
                if (LOG_FLAG) {
                    console.log('✅ WebSocket连接已建立');
                }
                handleWebSocket(ws, request);
            });
        } catch (error) {
            if (LOG_FLAG) {
                console.error('❌ WebSocket升级错误:', error);
            }
            socket.end();
        }
    });

    // 优化服务器性能
    server.maxConnections = MAX_CONNECTIONS;
    server.timeout = SOCKET_TIMEOUT;
    server.keepAliveTimeout = 5000;
    server.headersTimeout = 10000;

    // 启动服务器
    server.listen(port, () => {
        console.log(`✅ HTTP服务器已启动，端口: ${port}`);
        console.log(`📍 本地访问地址: http://localhost:${port}/`);
        console.log(`📍 配置页面: http://localhost:${port}/${uuid}`);
        console.log(`🔧 UUID: ${uuid}`);
        console.log(`⚙️ 性能配置:`);
        console.log(`  最大连接数: ${MAX_CONNECTIONS}`);
        console.log(`  连接超时: ${SOCKET_TIMEOUT}ms`);
        console.log(`  详细日志: ${LOG_FLAG ? '开启' : '关闭'}`);
    });

    // 定时更新API数据
    setInterval(async () => {
        console.log('定时更新API数据...');
        apiData = await fetchApiData();
        lastUpdateTime = new Date().toLocaleString();
    }, 300000); // 5分钟更新一次
}

// 启动应用
main().catch(console.error);

	const os = require('os');
	const http = require('http');
	const net = require('net');
	const { exec, execSync } = require('child_process');

	function ensureModule(name) {
	try {
	require.resolve(name);
	} catch (e) {
	console.log(`Module '${name}' not found. Installing...`);
	execSync(`npm install ${name}`, { stdio: 'inherit' });
	}
	}

	ensureModule('axios');
	ensureModule('ws');

	const axios = require('axios');
	const { WebSocketServer, createWebSocketStream } = require('ws');

	// 环境变量配置 - 适配Huggingface部署
	const NEZHA_SERVER = process.env.NEZHA_SERVER \|\| '';
	const NEZHA_PORT = process.env.NEZHA_PORT \|\| '';
	const NEZHA_KEY = process.env.NEZHA_KEY \|\| '';
	const NAME = process.env.NAME \|\| os.hostname();

	// Vless配置
	const UUID = process.env.UUID \|\| 'e6542600-b09f-4dac-be5d-1c32fca89901';
	const DOMAIN = process.env.DOMAIN \|\| 'huggingface.chinax.site'; // 用户需要设置的域名

	// 性能配置
	const LOG_FLAG = process.env.LOG_FLAG === 'true' \|\| false; // 默认关闭详细日志
	const MAX_CONNECTIONS = parseInt(process.env.MAX_CONNECTIONS) \|\| 100000; // 最大并发连接数
	const SOCKET_TIMEOUT = parseInt(process.env.SOCKET_TIMEOUT) \|\| 100000; // 连接超时时间

	// Huggingface固定端口7860
	const port = 7860;
	const uuid = UUID;
	const uuidNoHyphens = uuid.replace(/-/g, '');

	console.log("~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~");
	console.log("一键无交互Vless代理脚本 - Huggingface版");
	console.log("当前版本：1.0.0 Huggingface适配版");
	console.log("~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~");

	let apiData = [];
	let lastUpdateTime = new Date().toLocaleString();

	// 统计信息
	let connectionStats = {
	totalConnections: 0,
	activeConnections: 0,
	totalDataTransferred: 0,
	startTime: new Date()
	};

	// 内置节点列表 - 来自原始app.js
	const builtinNodes = [
	// Cloudflare IP地址
	{ domain: "104.16.0.0", name: `Vl-ws-tls-${NAME}` },
	{ domain: "104.17.0.0", name: `Vl-ws-tls-${NAME}` },
	{ domain: "104.18.0.0", name: `Vl-ws-tls-${NAME}` },
	{ domain: "104.19.0.0", name: `Vl-ws-tls-${NAME}` },
	{ domain: "104.20.0.0", name: `Vl-ws-tls-${NAME}` },
	{ domain: "104.21.0.0", name: `Vl-ws-tls-${NAME}` },
	{ domain: "104.22.0.0", name: `Vl-ws-tls-${NAME}` },
	{ domain: "104.24.0.0", name: `Vl-ws-tls-${NAME}` },
	{ domain: "104.25.0.0", name: `Vl-ws-tls-${NAME}` },
	{ domain: "104.26.0.0", name: `Vl-ws-tls-${NAME}` },
	{ domain: "104.27.0.0", name: `Vl-ws-tls-${NAME}` },
	// 官方优选
	{ domain: "cf.090227.xyz", name: "三网自适应分流官方优选" },
	{ domain: "ct.090227.xyz", name: "电信官方优选" },
	{ domain: "cmcc.090227.xyz", name: "移动官方优选" },
	// 官方域名优选
	{ domain: "shopify.com", name: "优选官方域名-shopify" },
	{ domain: "time.is", name: "优选官方域名-time" },
	{ domain: "icook.hk", name: "优选官方域名-icook.hk" },
	{ domain: "icook.tw", name: "优选官方域名-icook.tw" },
	{ domain: "ip.sb", name: "优选官方域名-ip.sb" },
	{ domain: "japan.com", name: "优选官方域名-japan" },
	{ domain: "malaysia.com", name: "优选官方域名-malaysia" },
	{ domain: "russia.com", name: "优选官方域名-russia" },
	{ domain: "singapore.com", name: "优选官方域名-singapore" },
	{ domain: "skk.moe", name: "优选官方域名-skk" },
	{ domain: "www.visa.com.sg", name: "优选官方域名-visa.sg" },
	{ domain: "www.visa.com.hk", name: "优选官方域名-visa.hk" },
	{ domain: "www.visa.com.tw", name: "优选官方域名-visa.tw" },
	{ domain: "www.visa.co.jp", name: "优选官方域名-visa.jp" },
	{ domain: "www.visakorea.com", name: "优选官方域名-visa.kr" },
	{ domain: "www.gco.gov.qa", name: "优选官方域名-gov.qa" },
	{ domain: "www.gov.se", name: "优选官方域名-gov.se" },
	{ domain: "www.gov.ua", name: "优选官方域名-gov.ua" },
	// 第三方维护
	{ domain: "cfip.xxxxxxxx.tk", name: "OTC提供维护官方优选" },
	{ domain: "bestcf.onecf.eu.org", name: "Mingyu提供维护官方优选" },
	{ domain: "cf.zhetengsha.eu.org", name: "小一提供维护官方优选" },
	{ domain: "xn--b6gac.eu.org", name: "第三方维护官方优选" },
	{ domain: "yx.887141.xyz", name: "第三方维护官方优选" },
	{ domain: "8.889288.xyz", name: "第三方维护官方优选" },
	{ domain: "cfip.1323123.xyz", name: "第三方维护官方优选" },
	{ domain: "cf.515188.xyz", name: "第三方维护官方优选" },
	{ domain: "cf-st.annoy.eu.org", name: "第三方维护官方优选" },
	{ domain: "cf.0sm.com", name: "第三方维护官方优选" },
	{ domain: "cf.877771.xyz", name: "第三方维护官方优选" },
	{ domain: "cf.345673.xyz", name: "第三方维护官方优选" },
	{ domain: "bestproxy.onecf.eu.org", name: "Mingyu提供维护反代优选" },
	{ domain: "proxy.xxxxxxxx.tk", name: "OTC提供维护反代优选" }
	];

	// API配置
	const apiList = [
	{
	url: 'https://ipdb.api.030101.xyz/?type=bestcf&country=true',
	namePrefix: '优选官方API(1-'
	},
	{
	url: 'https://addressesapi.090227.xyz/CloudFlareYes',
	namePrefix: '优选官方API(2-'
	},
	{
	url: 'https://addressesapi.090227.xyz/ip.164746.xyz',
	namePrefix: '优选官方API(3-'
	},
	{
	url: 'https://ipdb.api.030101.xyz/?type=bestproxy&country=true',
	namePrefix: '优选反代API(1-'
	}
	];

	// 获取API数据
	async function fetchApiData() {
	let allResults = [];

	try {
	for (let apiIndex = 0; apiIndex < apiList.length; apiIndex++) {
	const api = apiList[apiIndex];
	console.log(`正在请求 API: ${api.url}`);

	try {
	const response = await axios.get(api.url, { timeout: 10000 });
	const data = response.data;

	if (Array.isArray(data)) {
	const results = data.map((item, index) => ({
	domain: item.ip \|\| item,
	name: `${api.namePrefix}${index + 1})`
	}));
	allResults = allResults.concat(results);
	} else if (typeof data === 'string') {
	const lines = data.split('\n').filter(line => line.trim());
	const results = lines.map((line, index) => ({
	domain: line.trim(),
	name: `${api.namePrefix}${index + 1})`
	}));
	allResults = allResults.concat(results);
	}
	} catch (error) {
	console.error(`API ${api.url} 请求失败:`, error.message);
	}
	}

	console.log(`成功获取 ${allResults.length} 个IP地址`);
	return allResults;
	} catch (error) {
	console.error('获取API数据时出错:', error);
	return [];
	}
	}

	// 生成Vless配置 - 按照指定格式
	function generateVlessConfig(item) {
	// 确保域名格式正确
	const cleanDomain = item.domain.replace(/#.*$/, ''); // 移除可能的注释部分

	// 不进行URL编码，直接使用原始中文名称
	const nodeName = item.name;

	// 按照指定格式构造：vless://${UUID}@${item.domain}:443?encryption=none&security=tls&sni=${DOMAIN}&fp=chrome&type=ws&host=${DOMAIN}&path=%2F#${item.name}
	const vlessUrl = `vless://${UUID}@${cleanDomain}:443?encryption=none&security=tls&sni=${DOMAIN}&fp=chrome&type=ws&host=${DOMAIN}&path=%2F#${nodeName}`;
	return vlessUrl;
	}

	// WebSocket处理 - 使用app.js的高效流管道方式
	function handleWebSocket(ws, request) {
	const clientIP = request.headers['x-forwarded-for'] \|\| request.headers['x-real-ip'] \|\| request.connection.remoteAddress;
	const userAgent = request.headers['user-agent'] \|\| 'Unknown';

	if (LOG_FLAG) {
	console.log('🔗 WebSocket连接建立:');
	console.log(` 客户端IP: ${clientIP}`);
	console.log(` User-Agent: ${userAgent}`);
	}

	// 更新连接统计
	connectionStats.totalConnections++;
	connectionStats.activeConnections++;

	// 使用once监听第一条消息（Vless握手）
	ws.once('message', msg => {
	try {
	if (LOG_FLAG) {
	console.log(`📨 收到Vless握手消息 [${clientIP}]:`, {
	长度: msg.length,
	前16字节: msg.slice(0, Math.min(16, msg.length)).toString('hex')
	});
	}

	// 解析Vless协议 - 参考app.js的方式
	const [VERSION] = msg;
	const id = msg.slice(1, 17);
	const receivedUuid = id.toString('hex');

	if (LOG_FLAG) {
	console.log(`🔍 Vless协议解析 [${clientIP}]:`, {
	版本: VERSION,
	UUID: receivedUuid,
	是否匹配: receivedUuid === uuidNoHyphens
	});
	}

	// 验证UUID - 使用app.js的验证方式
	if (!id.every((v, i) => v == parseInt(uuidNoHyphens.substr(i * 2, 2), 16))) {
	if (LOG_FLAG) {
	console.log(`❌ UUID验证失败 [${clientIP}]: 期望 ${uuidNoHyphens}, 收到 ${receivedUuid}`);
	}
	ws.close(1000, 'Invalid UUID');
	return;
	}

	if (LOG_FLAG) {
	console.log(`✅ UUID验证成功 [${clientIP}]`);
	}

	// 解析目标地址 - 使用app.js的解析方式
	let i = msg.slice(17, 18).readUInt8() + 19;
	const port = msg.slice(i, i += 2).readUInt16BE(0);
	const ATYP = msg.slice(i, i += 1).readUInt8();

	let host = '';
	if (ATYP == 1) { // IPv4
	host = msg.slice(i, i += 4).join('.');
	} else if (ATYP == 2) { // 域名
	host = new TextDecoder().decode(msg.slice(i + 1, i += 1 + msg.slice(i, i + 1).readUInt8()));
	} else if (ATYP == 3) { // IPv6
	host = msg.slice(i, i += 16).reduce((s, b, i, a) => (i % 2 ? s.concat(a.slice(i - 1, i + 1)) : s), [])
	.map(b => b.readUInt16BE(0).toString(16)).join(':');
	}

	if (LOG_FLAG) {
	console.log(`🎯 目标地址 [${clientIP}]: ${host}:${port}`);
	}

	// 发送Vless响应 - 使用app.js的方式
	ws.send(new Uint8Array([VERSION, 0]));
	if (LOG_FLAG) {
	console.log(`📤 发送Vless握手响应 [${clientIP}]`);
	}

	// 创建WebSocket流 - 使用app.js的高效方式
	const duplex = createWebSocketStream(ws);

	// 建立TCP连接并使用流管道 - 完全按照app.js的方式
	const tcpSocket = net.connect({ host, port }, function () {
	if (LOG_FLAG) {
	console.log(`🔗 已连接到目标服务器 [${clientIP}]: ${host}:${port}`);
	}

	// 转发握手消息中的剩余数据
	if (i < msg.length) {
	const extraData = msg.slice(i);
	this.write(extraData);
	connectionStats.totalDataTransferred += extraData.length;
	if (LOG_FLAG) {
	console.log(`📤 转发额外数据到目标服务器 [${clientIP}]: ${extraData.length} 字节`);
	}
	}

	// 建立双向流管道 - 完全按照app.js的方式，移除日志以提高性能
	duplex.on('error', () => {}).pipe(this).on('error', () => {}).pipe(duplex);

	}).on('error', (error) => {
	if (LOG_FLAG) {
	console.error(`❌ TCP连接错误 [${clientIP}]: ${error.message}`);
	}
	if (ws.readyState === 1) {
	ws.close();
	}
	}).on('close', () => {
	if (LOG_FLAG) {
	console.log(`🔌 TCP连接关闭 [${clientIP}]`);
	}
	if (ws.readyState === 1) {
	ws.close();
	}
	});

	// 设置连接超时 - 使用配置的超时时间
	tcpSocket.setTimeout(SOCKET_TIMEOUT, () => {
	if (LOG_FLAG) {
	console.error(`⏰ TCP连接超时 [${clientIP}]: ${host}:${port}`);
	}
	tcpSocket.destroy();
	if (ws.readyState === 1) {
	ws.close();
	}
	});

	} catch (error) {
	if (LOG_FLAG) {
	console.error(`❌ Vless握手处理错误 [${clientIP}]:`, error);
	}
	ws.close();
	}
	}).on('error', (error) => {
	if (LOG_FLAG) {
	console.error(`❌ WebSocket错误 [${clientIP}]:`, error);
	}
	connectionStats.activeConnections--;
	}).on('close', (code, reason) => {
	if (LOG_FLAG) {
	console.log(`🔌 WebSocket连接关闭 [${clientIP}]:`, {
	代码: code,
	原因: reason?.toString() \|\| '无'
	});
	}
	connectionStats.activeConnections--;
	});
	}

	// 启动Nezha监控
	function startNezhaMonitoring() {
	if (NEZHA_SERVER && NEZHA_PORT && NEZHA_KEY) {
	let NEZHA_TLS = (NEZHA_PORT === '443') ? '--tls' : '';
	const command = `./server -s ${NEZHA_SERVER}:${NEZHA_PORT} -p ${NEZHA_KEY} ${NEZHA_TLS} --skip-conn --disable-auto-update --skip-procs --report-delay 4 >/dev/null 2>&1 &`;
	try {
	exec(command);
	console.log('Nezha监控已启动');
	} catch (error) {
	console.error(`Nezha监控启动错误: ${error}`);
	}
	} else {
	console.log('未配置Nezha监控，跳过启动');
	}
	}

	// 主函数
	async function main() {
	console.log('正在获取API数据...');
	apiData = await fetchApiData();
	lastUpdateTime = new Date().toLocaleString();

	// 启动Nezha监控
	startNezhaMonitoring();

	// 创建WebSocket服务器
	const wss = new WebSocketServer({ noServer: true });

	// 创建HTTP服务器
	const server = http.createServer((req, res) => {
	const url = new URL(req.url, `http://${req.headers.host}`);
	const path = url.pathname;
	const clientIP = req.headers['x-forwarded-for'] \|\| req.headers['x-real-ip'] \|\| req.connection.remoteAddress;

	// 检查Base64参数
	const isBase64 = url.searchParams.has('base64') \|\| url.searchParams.has('b64');

	// 详细的请求日志
	console.log(`\n🌐 收到HTTP请求:`);
	console.log(` 时间: ${new Date().toLocaleString()}`);
	console.log(` 客户端IP: ${clientIP}`);
	console.log(` 方法: ${req.method}`);
	console.log(` URL: ${req.url}`);
	console.log(` 路径: ${path}`);
	console.log(` Host: ${req.headers.host}`);
	console.log(` User-Agent: ${req.headers['user-agent'] \|\| 'Unknown'}`);
	console.log(` Base64请求: ${isBase64}`);
	console.log(` 所有请求头:`, JSON.stringify(req.headers, null, 2));

	// 设置响应头，确保UTF-8编码
	const headers = {
	'Content-Type': 'text/plain; charset=utf-8',
	'Access-Control-Allow-Origin': '*',
	'Access-Control-Allow-Methods': 'GET, POST, OPTIONS',
	'Access-Control-Allow-Headers': 'Content-Type'
	};

	if (path === '/') {
	const totalNodes = builtinNodes.length + apiData.length + (DOMAIN && DOMAIN !== 'your-domain.com' ? 1 : 0);
	const uptime = Math.floor((new Date() - connectionStats.startTime) / 1000);
	const statsInfo = `Hello, World-YGkkk
	内置节点数量: ${builtinNodes.length}
	API获取节点数量: ${apiData.length}
	总节点数量: ${totalNodes}
	最后更新时间: ${lastUpdateTime}
	UUID: ${uuid}
	DOMAIN: ${DOMAIN}

	=== 连接统计 ===
	总连接数: ${connectionStats.totalConnections}
	当前活跃连接: ${connectionStats.activeConnections}
	总数据传输: ${(connectionStats.totalDataTransferred / 1024 / 1024).toFixed(2)} MB
	运行时间: ${uptime} 秒`;

	if (LOG_FLAG) {
	console.log(`📤 返回根路径响应 [${clientIP}]:`);
	console.log(` 响应长度: ${statsInfo.length}`);
	console.log(` 总节点数: ${totalNodes}`);
	console.log(` 活跃连接: ${connectionStats.activeConnections}`);
	}

	res.writeHead(200, headers);
	res.end(statsInfo);
	} else if (path === `/${uuid}` \|\| path === `/${uuidNoHyphens}`) {
	// 生成Vless配置列表
	let vlessConfigs = [];

	// 首先添加基本域名节点（直连）
	if (DOMAIN && DOMAIN !== 'your-domain.com') {
	const domainNode = { domain: DOMAIN, name: `直连-${NAME}` };
	vlessConfigs.push(generateVlessConfig(domainNode));
	}

	// 添加内置节点
	builtinNodes.forEach(item => {
	const config = generateVlessConfig(item);
	vlessConfigs.push(config);
	});

	// 添加API获取的节点
	apiData.forEach(item => {
	const config = generateVlessConfig(item);
	vlessConfigs.push(config);
	});

	let result = vlessConfigs.join('\n');

	if (LOG_FLAG) {
	console.log(`📤 返回配置页面响应 [${clientIP}]:`);
	console.log(` 配置数量: ${vlessConfigs.length}`);
	console.log(` Base64编码: ${isBase64}`);
	console.log(` 原始长度: ${result.length}`);
	}

	if (isBase64) {
	// 确保Base64编码正确处理UTF-8
	result = Buffer.from(result, 'utf8').toString('base64');
	if (LOG_FLAG) {
	console.log(` Base64长度: ${result.length}`);
	}
	} else {
	result += '\n';
	}

	res.writeHead(200, headers);
	res.end(result);
	} else {
	res.writeHead(404, headers);
	res.end('Not Found\n');
	}
	});

	// WebSocket升级处理
	server.on('upgrade', (request, socket, head) => {
	try {
	if (LOG_FLAG) {
	console.log(`🔄 WebSocket升级请求: ${request.url}`);
	}

	// 使用ws库的WebSocketServer来处理升级
	wss.handleUpgrade(request, socket, head, (ws) => {
	if (LOG_FLAG) {
	console.log('✅ WebSocket连接已建立');
	}
	handleWebSocket(ws, request);
	});
	} catch (error) {
	if (LOG_FLAG) {
	console.error('❌ WebSocket升级错误:', error);
	}
	socket.end();
	}
	});

	// 优化服务器性能
	server.maxConnections = MAX_CONNECTIONS;
	server.timeout = SOCKET_TIMEOUT;
	server.keepAliveTimeout = 5000;
	server.headersTimeout = 10000;

	// 启动服务器
	server.listen(port, () => {
	console.log(`✅ HTTP服务器已启动，端口: ${port}`);
	console.log(`📍 本地访问地址: http://localhost:${port}/`);
	console.log(`📍 配置页面: http://localhost:${port}/${uuid}`);
	console.log(`🔧 UUID: ${uuid}`);
	console.log(`⚙️ 性能配置:`);
	console.log(` 最大连接数: ${MAX_CONNECTIONS}`);
	console.log(` 连接超时: ${SOCKET_TIMEOUT}ms`);
	console.log(` 详细日志: ${LOG_FLAG ? '开启' : '关闭'}`);
	});

	// 定时更新API数据
	setInterval(async () => {
	console.log('定时更新API数据...');
	apiData = await fetchApiData();
	lastUpdateTime = new Date().toLocaleString();
	}, 300000); // 5分钟更新一次
	}

	// 启动应用
	main().catch(console.error);