Update server.ts

server.ts

@@ -6,7 +6,7 @@ import path from "path";
 import mineflayer from "mineflayer";
 import pkg from "mineflayer-pathfinder";
 const { pathfinder, Movements, goals } = pkg;
-import { GoogleGenAI } from "@google/genai";
+import { GoogleGenAI, Type } from "@google/genai";
 
 const app = express();
 const httpServer = createServer(app);
@@ -17,6 +17,7 @@ const io = new Server(httpServer, {
 });
 
 const PORT = Number(process.env.PORT) || 7860;
+
 let bot: mineflayer.Bot | null = null;
 let ai: GoogleGenAI | null = null;
 let selectedModel: string = "gemini-3-flash-preview";
@@ -27,24 +28,25 @@ let maxBlocks: number = 10000;
 let globalApiKey: string = "";
 let chatHistory: { role: string, content: string }[] = [];
 
-// Помощник для логов
+// Helper to log to frontend
 const log = (message: string, type: "info" | "success" | "error" | "chat" = "info") => {
   io.emit("bot-log", { message, type, timestamp: new Date().toISOString() });
   console.log(`[${type.toUpperCase()}] ${message}`);
 };
 
 async function startServer() {
-  // API Статус
+  // API Routes
   app.get("/api/status", (req, res) => {
     res.json({ connected: !!bot, username: bot?.username });
   });
 
-  // Socket.io управление
+  // Socket.io for Bot Control
   io.on("connection", (socket) => {
     log("Frontend connected to control panel");
 
     socket.on("connect-bot", (config) => {
       const { host, port, version, username, apiKey, model } = config;
+
       if (bot) {
         bot.quit();
         log("Existing bot disconnected");
@@ -63,13 +65,12 @@ async function startServer() {
         } else {
           ai = null;
         }
-
+        
         bot = mineflayer.createBot({
           host,
           port: parseInt(port) || 25565,
           username,
           version: version || false,
-          checkTimeoutInterval: 60000, // Увеличиваем ожидание ответа от сервера
         });
 
         bot.loadPlugin(pathfinder);
@@ -83,13 +84,11 @@ async function startServer() {
           if (username === bot?.username) return;
           log(`${username}: ${message}`, "chat");
 
-          // Реагируем на !build / !б
+          // Проверяем на !build ИЛИ !б
           if (message.startsWith("!build ") || message.startsWith("!б ")) {
             const prompt = message.substring(message.indexOf(" ") + 1);
             await handleBuildRequest(prompt, username, false);
-          } 
-          // Реагируем на !next / !н
-          else if (message.startsWith("!next ") || message.startsWith("!н ")) {
+          } else if (message.startsWith("!next ") || message.startsWith("!н ")) {
             const prompt = message.substring(message.indexOf(" ") + 1);
             await handleBuildRequest(prompt, username, true);
           }
@@ -101,6 +100,7 @@ async function startServer() {
           bot = null;
           io.emit("bot-status", { connected: false });
         });
+
       } catch (error: any) {
         log(`Failed to initialize: ${error.message}`, "error");
       }
@@ -118,118 +118,225 @@ async function startServer() {
 
   async function handleBuildRequest(prompt: string, requestingUser: string, isNext: boolean) {
     if (!bot) return;
+
     log(`AI is thinking about: "${prompt}"...`);
-    bot.chat(`Request received, thinking...`);
+    bot.chat(`Request received from ${requestingUser}, beginning generation...`);
 
     try {
-      const systemPrompt = `You are a Minecraft architect and admin. The user "${requestingUser}" wants: "${prompt}".
-        Coordinates (x, y, z) are relative to the bot's position at the START of the generation (0,0,0).
-        For commands, use relative coordinates (~ ~ ~) where appropriate.
+      const nearbyPlayers = Object.values(bot.players)
+        .filter(p => p.username !== bot?.username && p.entity)
+        .map(p => `${p.username} (distance: ${Math.round(bot!.entity.position.distanceTo(p.entity.position))}m)`)
+        .join(", ") || "No one nearby";
+
+      const systemPrompt = `You are a Minecraft architect, admin, and player. The user "${requestingUser}" wants: "${prompt}". 
+        You can build structures, execute commands, move around, or interact with players.
+        Coordinates (x, y, z) for blocks and movement are relative to the bot's starting position (0,0,0). 
+        For commands (like /summon), use relative coordinates (~ ~ ~) which are relative to the bot!
+        Use standard Minecraft 1.21.1 block names and command syntax.
+        
+        ENVIRONMENT CONTEXT (What you currently see):
+        - Nearby players: ${nearbyPlayers}
+        - Your position: ${Math.round(bot.entity.position.x)}, ${Math.round(bot.entity.position.y)}, ${Math.round(bot.entity.position.z)}
+        
+        CRITICAL 1.21.1 COMMAND SYNTAX:
+        - Items with custom names/enchantments: give ${requestingUser} cobblestone[custom_name=[{"text":"Name","italic":false}],enchantments={channeling:1}]
+        - Summoning entities with visible names: summon armor_stand ~2 ~ ~ {CustomName:'{"text":"Palace"}',CustomNameVisible:1b,ArmorItems:[{},{},{},{id:"minecraft:shield",count:1}]}
         
-        CRITICAL RULES:
-        1. Output ONLY a valid JSON object. 
-        2. STRICTLY NO comments (like // or /*) inside the JSON.
-        3. Use Minecraft 1.21.1 syntax.
-        4. If the user says "come to me", use action ["cmd", "tp @s ${requestingUser}"].
+        IMPORTANT: To avoid getting stuck inside the blocks you place, ALWAYS start your actions by teleporting or moving away from the build area.
+        If you need to attack someone, equip a weapon first using: ["cmd", "item replace entity @s weapon.mainhand with diamond_sword"]
         
-        Action types:
-        - [x, y, z, "block_name"] : Place block
-        - ["cmd", "command"] : Execute command
-        - ["move", x, y, z] : Walk to relative pos
-        - ["tp", x, y, z] : Teleport to relative pos
+        You can build large structures up to ${maxBlocks} blocks.
+        To save tokens, output a JSON object containing an "actions" array.
+        Action type 1 (Place Block): [x, y, z, "block_name"]
+        Action type 2 (Execute Command): ["cmd", "command_string"]
+        Action type 3 (Walk/Parkour): ["move", x, y, z]
+        Action type 4 (Teleport): ["tp", x, y, z]
+        Action type 5 (Attack Player): ["attack", "player_name"]
+        Action type 6 (Follow Player): ["follow", "player_name"]
         
-        Example: {"actions": [["cmd", "gamemode creative @s"], [0, 5, 0, "stone"]]}`;
+        Example:
+        {
+          "actions": [
+            ["cmd", "item replace entity @s weapon.mainhand with diamond_sword"],
+            ["attack", "PlayerName"]
+          ]
+        }
+        Output ONLY the JSON object.`;
 
-      if (!isNext) chatHistory = [];
-      
-      let userMessage = isNext 
-        ? `CONTINUE/MODIFY build. User says: "${prompt}". Output FULL JSON with new actions.`
-        : prompt;
+      if (!isNext) {
+        chatHistory = [];
+      }
+
+      let userMessage = prompt;
+      if (isNext) {
+         userMessage = `CONTINUE OR MODIFY THE PREVIOUS BUILD. User request: "${prompt}". Output the FULL JSON array of actions to execute next (e.g. replacing blocks, adding new ones, etc). Keep in mind the coordinates of the previous blocks.`;
+      }
 
       chatHistory.push({ role: "user", content: userMessage });
 
       let responseText = "";
+
       if (apiType === "openai") {
         const url = apiBaseUrl.replace(/\/+$/, '') + '/chat/completions';
+        const messages = [
+          { role: "system", content: systemPrompt },
+          ...chatHistory
+        ];
+
         const res = await fetch(url, {
           method: "POST",
-          headers: { "Content-Type": "application/json", "Authorization": `Bearer ${globalApiKey}` },
+          headers: {
+            "Content-Type": "application/json",
+            "Authorization": `Bearer ${globalApiKey}`
+          },
           body: JSON.stringify({
             model: customModel || "gpt-3.5-turbo",
-            messages: [{ role: "system", content: systemPrompt }, ...chatHistory]
+            messages: messages
           })
         });
+        
+        if (!res.ok) {
+          const errText = await res.text();
+          throw new Error(`Custom API Error: ${res.status} ${errText}`);
+        }
+        
         const data = await res.json();
         responseText = data.choices[0].message.content;
       } else {
-        if (!ai) throw new Error("AI not initialized");
+        if (!ai) throw new Error("Google GenAI not initialized");
+        
         const contents = chatHistory.map(msg => ({
           role: msg.role === "assistant" ? "model" : "user",
           parts: [{ text: msg.content }]
         }));
+
         const response = await ai.models.generateContent({
           model: selectedModel,
           contents: contents,
-          config: { systemInstruction: systemPrompt, responseMimeType: "application/json" }
+          config: {
+            systemInstruction: systemPrompt,
+            responseMimeType: "application/json",
+          }
         });
         responseText = response.text;
       }
 
       chatHistory.push({ role: "assistant", content: responseText });
 
-      // Чистка JSON
+      // Clean up markdown formatting if present
       responseText = responseText.replace(/```json/g, '').replace(/```/g, '').trim();
+      
+      // Fix bad control characters (like literal newlines or tabs inside strings) that break JSON.parse
       responseText = responseText.replace(/[\n\r\t]/g, ' ').replace(/[\x00-\x1F\x7F-\x9F]/g, '');
       
-      const { actions } = JSON.parse(responseText);
-      if (!Array.isArray(actions)) throw new Error("Missing actions array");
+      const parsed = JSON.parse(responseText);
+      const actions = parsed.actions;
+      
+      if (!Array.isArray(actions)) throw new Error("Invalid AI response format: missing 'actions' array");
+
+      log(`AI generated ${actions.length} actions. Muting command feedback and starting execution...`, "success");
 
-      log(`Executing ${actions.length} actions...`, "success");
+      // Disable command feedback in Minecraft to prevent chat spam
       bot.chat('/gamerule sendCommandFeedback false');
+      bot.chat('/gamerule logAdminCommands false');
+      bot.chat('/gamemode creative @s'); // Ensure bot is in creative so it doesn't suffocate
+
       const startPos = bot.entity.position.clone();
 
       for (const action of actions) {
         if (!bot) break;
-        await new Promise(r => setTimeout(r, 100));
-
+        if (!Array.isArray(action)) continue;
+        
         try {
-          if (action[0] === "cmd") {
-            bot.chat(`/${action[1].startsWith('/') ? action[1].slice(1) : action[1]}`);
-          } else if (action[0] === "move") {
-            const target = startPos.offset(action[1], action[2], action[3]);
-            bot.pathfinder.setMovements(new Movements(bot));
-            await bot.pathfinder.goto(new goals.GoalBlock(target.x, target.y, target.z));
-          } else if (action[0] === "tp") {
-            bot.chat(`/tp @s ~${action[1]} ~${action[2]} ~${action[3]}`);
-          } else if (action.length >= 4) {
-            const target = startPos.offset(action[0], action[1], action[2]);
-            let block = String(action[3]).toLowerCase();
-            if (!block.startsWith('minecraft:')) block = `minecraft:${block}`;
-            bot.chat(`/setblock ${Math.floor(target.x)} ${Math.floor(target.y)} ${Math.floor(target.z)} ${block}`);
-          }
+           // 100ms delay to speed up building while avoiding anti-spam kicks (10 blocks/sec)
+           await new Promise(r => setTimeout(r, 100));
+           
+           if (action[0] === "cmd" && typeof action[1] === "string") {
+             let cmd = action[1];
+             if (cmd.startsWith("/")) cmd = cmd.substring(1);
+             log(`Executing command: /${cmd}`, "info");
+             bot.chat(`/${cmd}`);
+           } else if (action[0] === "move") {
+             const dx = Number(action[1]) || 0;
+             const dy = Number(action[2]) || 0;
+             const dz = Number(action[3]) || 0;
+             const targetPos = startPos.offset(dx, dy, dz);
+             log(`Walking to ~${dx} ~${dy} ~${dz}...`, "info");
+             const defaultMove = new Movements(bot);
+             bot.pathfinder.setMovements(defaultMove);
+             try {
+               await bot.pathfinder.goto(new goals.GoalBlock(targetPos.x, targetPos.y, targetPos.z));
+             } catch (e) {
+               log(`Pathfinding failed or interrupted`, "error");
+             }
+           } else if (action[0] === "tp") {
+             const dx = Number(action[1]) || 0;
+             const dy = Number(action[2]) || 0;
+             const dz = Number(action[3]) || 0;
+             log(`Teleporting to ~${dx} ~${dy} ~${dz}`, "info");
+             bot.chat(`/tp @s ~${dx} ~${dy} ~${dz}`);
+             await new Promise(r => setTimeout(r, 500)); // Wait for teleport to complete
+           } else if (action[0] === "attack" || action[0] === "follow") {
+             const targetName = action[1];
+             const target = bot.players[targetName]?.entity;
+             if (target) {
+               log(`${action[0] === "attack" ? "Attacking" : "Following"} ${targetName}...`, "info");
+               const defaultMove = new Movements(bot);
+               bot.pathfinder.setMovements(defaultMove);
+               try {
+                 await bot.pathfinder.goto(new goals.GoalNear(target.position.x, target.position.y, target.position.z, action[0] === "attack" ? 2 : 3));
+                 if (action[0] === "attack") {
+                   bot.attack(target);
+                 }
+               } catch (e) {
+                 log(`Could not reach ${targetName}`, "error");
+               }
+             } else {
+               log(`Cannot find player ${targetName}`, "error");
+             }
+           } else if (action.length >= 4) {
+             const [x, y, z, rawBlock] = action;
+             const targetPos = startPos.offset(x, y, z);
+             
+             // Ensure block name has minecraft: prefix if it doesn't already
+             let blockName = String(rawBlock).toLowerCase();
+             if (!blockName.startsWith('minecraft:')) {
+               blockName = `minecraft:${blockName}`;
+             }
+
+             // @ts-ignore
+             bot.chat(`/setblock ${Math.floor(targetPos.x)} ${Math.floor(targetPos.y)} ${Math.floor(targetPos.z)} ${blockName}`);
+           }
         } catch (e) {
-          log("Action failed", "error");
+           log(`Failed to execute action: ${JSON.stringify(action)}`, "error");
         }
       }
-      bot.chat("Done!");
+
+      bot.chat("Generation complete.");
+      log("Generation complete!", "success");
     } catch (error: any) {
-      log(`Error: ${error.message}`, "error");
-      bot.chat(`Error: ${error.message}`);
+      log(`AI Error: ${error.message}`, "error");
+      bot.chat(`Error during generation: ${error.message}`);
     }
   }
 
-  // Vite / Static
+  // Vite middleware for development
   if (process.env.NODE_ENV !== "production") {
-    const vite = await createViteServer({ server: { middlewareMode: true }, appType: "spa" });
+    const vite = await createViteServer({
+      server: { middlewareMode: true },
+      appType: "spa",
+    });
     app.use(vite.middlewares);
   } else {
     const distPath = path.join(process.cwd(), "dist");
     app.use(express.static(distPath));
-    app.get("*", (req, res) => res.sendFile(path.join(distPath, "index.html")));
+    app.get("*", (req, res) => {
+      res.sendFile(path.join(distPath, "index.html"));
+    });
   }
 
   httpServer.listen(PORT, "0.0.0.0", () => {
-    log(`Server running on port ${PORT}`, "success");
+    log(`Server running on http://localhost:${PORT}`, "success");
   });
 }