how to solve socketclosed?

[hseermc]

i connect to a minecraft server,but i only know the IP without the port. I filled in the perfectworld.cloud in the host field and left a blank in the port field. Then I tried to connect to the server. But within 3 seconds, the socketclosed disconnect appears.I can make sure that I can use Java Edition minecraft to enter the server.The server use paper 1.21.4
Here is my code.

const mineflayer = require('mineflayer');
const readline = require('readline');
const fs = require('fs');
const path = require('path');
const yaml = require('js-yaml');
const chalk = require('chalk').default; // 用于彩色控制台输出
const { pathfinder } = require('mineflayer-pathfinder');
const { ChatMessage } = require('prismarine-chat'); // 用于解析聊天组件

// 配置文件路径
const configPath = path.join(__dirname, 'config', 'options.yml');

// 加载配置
let config;
try {
    const fileContents = fs.readFileSync(configPath, 'utf8');
    config = yaml.load(fileContents);
} catch (e) {
    console.error('配置文件加载失败:', e.message);
    process.exit(1);
}

// 聊天消息处理器类定义（放在使用之前）
class ChatHandler {
    constructor(bot) {
        this.bot = bot;
        this.messageFormats = {
            chat: chalk.cyan('[聊天]'),
            system: chalk.yellow('[系统]'),
            whisper: chalk.magenta('[私聊]'),
            action: chalk.green('[动作]'),
            death: chalk.red('[死亡]'),
            join: chalk.greenBright('[加入]'),
            leave: chalk.redBright('[离开]'),
            achievement: chalk.blue('[成就]'),
            team: chalk.hex('#FFA500')('[队伍]'),
            error: chalk.red.bold('[错误]'),
            command: chalk.blueBright('[命令]'),
            send: chalk.green('[发送]')
        };
    }

    // 格式化时间戳
    getTimestamp() {
        const now = new Date();
        return chalk.gray(`[${now.getHours().toString().padStart(2, '0')}:` +
                          `${now.getMinutes().toString().padStart(2, '0')}:` +
                          `${now.getSeconds().toString().padStart(2, '0')}]`);
    }

    // 解析聊天组件
    parseChatComponent(jsonMsg) {
    if (typeof jsonMsg === 'string') return jsonMsg;
    
    try {
        // 直接提取文本内容
        if (jsonMsg.text) return jsonMsg.text;
        
        // 处理带有额外字段的消息
        if (jsonMsg.extra && Array.isArray(jsonMsg.extra)) {
            return jsonMsg.extra.map(item => item.text).join('');
        }
        
        return JSON.stringify(jsonMsg);
    } catch (e) {
        return '无法解析的消息';
    }
}
    // 处理聊天消息
handleChat(jsonMsg, position = 'chat') {
    const timestamp = this.getTimestamp();
    const rawMessage = this.parseChatComponent(jsonMsg);
    
    // 根据事件类型而不是内容判断消息类型
    let messageType = 'chat';
    
    switch (position) {
        case 'system':
        case 'game_info':
            messageType = 'system';
            break;
        case 'action_bar':
            messageType = 'action';
            break;
        default:
            // 仅对普通聊天消息进行内容分析
            if (position === 'chat') {
                if (rawMessage.startsWith('* ')) {
                    messageType = 'action';
                } else if (rawMessage.includes('悄悄对你说') || 
                          rawMessage.includes('whispers to you')) {
                    messageType = 'whisper';
                } 
                // 移除玩家加入/离开等内容的判断
            }
    }
    
    // 应用格式前缀
    const formattedMessage = `${timestamp} ${this.messageFormats[messageType]} ${rawMessage}`;
    console.log(formattedMessage);
    this.saveToLog(rawMessage);
}

    // 保存消息到日志文件
    saveToLog(message) {
        if (!config.chat || !config.chat.logToFile) return;
        
        const logPath = config.chat.logFile || 'chat.log';
        const timestamp = new Date().toISOString();
        
        fs.appendFile(logPath, `[${timestamp}] ${message}\n`, (err) => {
            if (err) console.error('日志写入失败:', err.message);
        });
    }
    
    // 处理发送的消息
    logSentMessage(message) {
        const timestamp = this.getTimestamp();
        console.log(`${timestamp} ${this.messageFormats.send} ${message}`);
        this.saveToLog(`${this.bot.username} (发送): ${message}`);
    }
}

// 创建机器人实例的函数（用于自动重连）
function createBotInstance() {
    const instance = mineflayer.createBot({
        host: config.bot.host,
        port: config.bot.port,
        username: config.bot.username,
        password: config.bot.password,
        version: config.bot.version,
        auth: config.bot.auth,
        authServer: config.bot.authServer,
        authTitle: config.bot.authTitle
    });
    
    // 加载路径查找插件
    instance.loadPlugin(pathfinder);
    
    return instance;
}

// 创建机器人实例
let bot = createBotInstance();

// 创建聊天处理器实例
let chatHandler = new ChatHandler(bot);

// 设置控制台输入
const rl = readline.createInterface({
    input: process.stdin,
    output: process.stdout,
    prompt: `${config.bot.username}> `,
    historySize: 100 // 保存100条历史记录
});

console.log('正在连接到服务器...');
console.log(chalk.green(`√ 正在连接到 ${config.bot.host}:${config.bot.port}`));

// 功能状态追踪器
const activeFunctions = {};

// 设置事件监听器
function setupEventListeners() {
    // 登录事件
    bot.on('login', () => {
        console.log(chalk.green(`√ 成功登录到 ${config.bot.host}:${config.bot.port}`));
        console.log(`👤 用户名: ${config.bot.username}`);
        
        if (config.bot.debug) {
            console.log('🔧 调试模式已启用');
        }
        
        // 显示命令提示
        console.log('📝 输入消息直接发送到服务器，或使用以下命令:');
        console.log('  !help - 显示帮助信息');
        console.log('  !players - 列出在线玩家');
        console.log('  !start [功能名] - 启动功能');
        console.log('  !stop [功能名] - 停止功能');
        console.log('  !format - 切换消息格式');
        console.log('  !log - 切换日志记录');
        console.log('  !quit - 退出程序');
        
        rl.prompt();
        
        // 检查并启动配置文件中启用的功能
        checkAndStartFunctions();
    });
    
    // 错误事件
    bot.on('error', (err) => {
        console.error('❌ 连接错误:', err.message);
    });
    
    // 断开连接事件
    bot.on('end', (reason) => {
        console.log(`🔌 连接已断开: ${reason}`);
        if (config.bot.autoReconnect) {
            console.log('⏳ 5秒后尝试重新连接...');
            setTimeout(() => {
                console.log('重新连接中...');
                bot = createBotInstance();
                chatHandler = new ChatHandler(bot); // 重新创建聊天处理器
                setupEventListeners();
            }, 5000);
        } else {
            rl.close();
        }
    });
    
    // 处理游戏内命令
    bot.on('chat', (username, message) => {
        // 忽略机器人自己的消息
        if (username === bot.username) return;
        
        // 处理游戏内命令
        if (message.startsWith('!')) {
            const [command, ...args] = message.slice(1).split(' ');
            
            switch (command.toLowerCase()) {
                case 'start':
                    if (args.length > 0) {
                        startFunction(args[0]);
                        bot.chat(`功能 ${args[0]} 已启动`);
                    }
                    break;
                    
                case 'stop':
                    if (args.length > 0) {
                        stopFunction(args[0]);
                        bot.chat(`功能 ${args[0]} 已停止`);
                    }
                    break;
                    
                case 'help':
                    bot.chat('可用命令: !start [功能], !stop [功能], !players');
                    break;
            }
        }
    });
}

// 启动功能
function startFunction(name) {
    if (activeFunctions[name]) {
        console.log(`功能 ${name} 已经在运行`);
        return;
    }
    
    console.log(`启动功能: ${name}`);
    
    switch (name) {
        case 'autochat':
            // 创建新的监听器
            const autochatListener = (username, message) => {
                if (username === bot.username) return;
                
                // 简单的自动回复
                if (message.toLowerCase().includes('你好')) {
                    bot.chat('你好! 我是HSEERMC助手，有什么可以帮您的吗?');
                } else if (message.toLowerCase().includes('帮助')) {
                    bot.chat('你可以问我: "时间" 或 "天气"，或者输入 !help 查看所有命令');
                } else if (message.toLowerCase().includes('时间')) {
                    const now = new Date();
                    bot.chat(`现在时间是: ${now.toLocaleTimeString()}`);
                }
            };
            
            // 添加监听器并保存引用
            bot.on('chat', autochatListener);
            activeFunctions.autochat = autochatListener;
            break;
            
        case 'lookatnerestentity':
            const entityListener = () => {
                const entity = bot.nearestEntity(e => e.type !== 'player');
                if (entity) {
                    const pos = entity.position.offset(0, entity.height, 0);
                    bot.lookAt(pos);
                }
            };
            
            bot.on('physicTick', entityListener);
            activeFunctions.lookatnerestentity = entityListener;
            break;
            
        case 'lookatnerestplayer':
            const playerListener = () => {
                const player = bot.nearestEntity(e => e.type === 'player' && e.username !== bot.username);
                if (player) {
                    const pos = player.position.offset(0, player.height, 0);
                    bot.lookAt(pos);
                }
            };
            
            bot.on('physicTick', playerListener);
            activeFunctions.lookatnerestplayer = playerListener;
            break;
            
        case 'autowalk':
            console.log('自动行走功能启动');
            bot.chat('自动行走功能已启动');
            // 这里可以添加自动行走的具体实现
            break;
            
        default:
            console.log(`未知功能: ${name}`);
    }
}

// 停止功能
function stopFunction(name) {
    if (!activeFunctions[name]) {
        console.log(`功能 ${name} 未在运行`);
        return;
    }
    
    console.log(`停止功能: ${name}`);
    
    // 移除事件监听器
    switch (name) {
        case 'autochat':
            bot.removeListener('chat', activeFunctions[name]);
            break;
            
        case 'lookatnerestentity':
        case 'lookatnerestplayer':
            bot.removeListener('physicTick', activeFunctions[name]);
            break;
    }
    
    // 从活动功能中移除
    delete activeFunctions[name];
}

// 检查并启动配置文件中启用的功能
function checkAndStartFunctions() {
    if (config.autochat && !activeFunctions.autochat) {
        startFunction('autochat');
    }
    if (config.lookatnerestentity && !activeFunctions.lookatnerestentity) {
        startFunction('lookatnerestentity');
    }
    if (config.lookatnerestplayer && !activeFunctions.lookatnerestplayer) {
        startFunction('lookatnerestplayer');
    }
    if (config.autowalk) {
        startFunction('autowalk');
    }
}

// 处理控制台输入
rl.on('line', (input) => {
    const trimmedInput = input.trim();
    
    if (!trimmedInput) {
        rl.prompt();
        return;
    }
    
    // 处理命令
    if (trimmedInput.startsWith('!')) {
        const [command, ...args] = trimmedInput.slice(1).split(' ');
        
        switch (command.toLowerCase()) {
            case 'start':
                if (args.length > 0) {
                    startFunction(args[0]);
                } else {
                    console.log('用法: !start [功能名]');
                }
                break;
                
            case 'stop':
                if (args.length > 0) {
                    stopFunction(args[0]);
                } else {
                    console.log('用法: !stop [功能名]');
                }
                break;
                
            case 'players':
                if (!bot.players) {
                    console.log('机器人尚未完全连接');
                    break;
                }
                
                const players = Object.keys(bot.players)
                    .filter(name => bot.players[name].entity !== bot.entity)
                    .map(name => bot.players[name].username);
                
                if (players.length === 0) {
                    console.log('当前没有其他玩家在线');
                } else {
                    console.log(`在线玩家 (${players.length}):`);
                    console.log(players.join(', '));
                }
                break;
                
            case 'help':
                console.log('可用命令:');
                console.log('  !start [功能名] - 启动功能 (autochat, lookatnerestentity, etc)');
                console.log('  !stop [功能名] - 停止功能');
                console.log('  !players - 列出在线玩家');
                console.log('  !format - 切换消息格式 [简约/详细]');
                console.log('  !log - 切换日志记录 [开/关]');
                console.log('  !status - 显示连接状态');
                console.log('  !quit - 退出程序');
                break;
                
            case 'format':
                config.chat = config.chat || {};
                config.chat.detailedFormat = !config.chat.detailedFormat;
                console.log(`消息格式已切换为: ${config.chat.detailedFormat ? '详细' : '简约'}`);
                break;
                
            case 'log':
                config.chat = config.chat || {};
                config.chat.logToFile = !config.chat.logToFile;
                console.log(`日志记录已${config.chat.logToFile ? '启用' : '禁用'}`);
                break;
                
            case 'status':
                console.log('当前连接状态:');
                console.log(`- 服务器: ${bot._client.socket.remoteAddress}:${bot._client.socket.remotePort}`);
                console.log(`- 协议版本: ${bot.version}`);
                if (bot.game) {
                    console.log(`- 游戏模式: ${bot.game.gameMode}`);
                    console.log(`- 世界维度: ${bot.game.dimension}`);
                } else {
                    console.log('- 游戏状态: 尚未完全连接');
                }
                break;
                
            case 'quit':
            case 'exit':
                console.log('正在退出...');
                bot.end();
                rl.close();
                process.exit(0);
                break;
                
            default:
                console.log(`未知命令: ${command}`);
                console.log('输入 !help 查看帮助');
        }
    } else {
        // 发送普通消息到服务器
        bot.chat(trimmedInput);
        // 记录发送的消息
        chatHandler.logSentMessage(trimmedInput);
    }
    
    rl.prompt();
}).on('close', () => {
    console.log('再见!');
    bot.end();
    process.exit(0);
});

// 程序退出处理
process.on('SIGINT', () => {
    console.log('\n正在退出...');
    bot.end();
    rl.close();
    process.exit();
});

// 初始设置事件监听器
setupEventListeners();