valheim-oz-dsm 1.5.4 → 1.8.0

package/dist/main.js

@@ -10,10 +10,20 @@ var __export = (target, all) => {
 };
 
 // src/rcon/types.ts
-var RconError;
+var PacketType, RconError, ValheimCommands, ValheimEvents, ValheimGlobalKeys;
 var init_types = __esm({
   "src/rcon/types.ts"() {
     "use strict";
+    PacketType = {
+      /** Authentication request */
+      SERVERDATA_AUTH: 3,
+      /** Authentication response */
+      SERVERDATA_AUTH_RESPONSE: 2,
+      /** Execute command */
+      SERVERDATA_EXECCOMMAND: 2,
+      /** Command response */
+      SERVERDATA_RESPONSE_VALUE: 0
+    };
     RconError = class extends Error {
       constructor(code, message) {
         super(message);
@@ -21,6 +31,81 @@ var init_types = __esm({
         this.name = "RconError";
       }
     };
+    ValheimCommands = {
+      // Server Management
+      /** Force save world */
+      SAVE: "save",
+      /** Get server info */
+      INFO: "info",
+      /** Ping server */
+      PING: "ping",
+      // Player Management
+      /** Kick player */
+      kick: (player) => `kick ${player}`,
+      /** Ban player */
+      ban: (player) => `ban ${player}`,
+      /** Unban player */
+      unban: (player) => `unban ${player}`,
+      /** List banned players */
+      BANNED: "banned",
+      /** List permitted players */
+      PERMITTED: "permitted",
+      // Time Control
+      /** Sleep through night (skip to morning) */
+      SLEEP: "sleep",
+      /** Skip time by seconds */
+      skiptime: (seconds) => `skiptime ${seconds}`,
+      // Events
+      /** Trigger specific event */
+      event: (eventName) => `event ${eventName}`,
+      /** Trigger random event */
+      RANDOMEVENT: "randomevent",
+      /** Stop current event */
+      STOPEVENT: "stopevent",
+      // World Management
+      /** Remove all dropped items */
+      REMOVEDROPS: "removedrops",
+      /** Set a global key */
+      setkey: (key) => `setkey ${key}`,
+      /** Remove a global key */
+      removekey: (key) => `removekey ${key}`,
+      /** Reset all global keys */
+      RESETKEYS: "resetkeys",
+      /** List all global keys */
+      LISTKEYS: "listkeys",
+      // Performance
+      /** Set LOD bias (0-5, lower = better performance) */
+      lodbias: (value) => `lodbias ${value}`,
+      /** Set LOD distance (100-6000) */
+      loddist: (value) => `loddist ${value}`
+    };
+    ValheimEvents = {
+      ARMY_EIKTHYR: "army_eikthyr",
+      ARMY_THEELDER: "army_theelder",
+      ARMY_BONEMASS: "army_bonemass",
+      ARMY_MODER: "army_moder",
+      ARMY_GOBLIN: "army_goblin",
+      FORESTTROLLS: "foresttrolls",
+      SKELETONS: "skeletons",
+      BLOBS: "blobs",
+      WOLVES: "wolves",
+      BATS: "bats",
+      SERPENTS: "serpents"
+    };
+    ValheimGlobalKeys = {
+      DEFEATED_EIKTHYR: "defeated_eikthyr",
+      DEFEATED_GDKING: "defeated_gdking",
+      // The Elder
+      DEFEATED_BONEMASS: "defeated_bonemass",
+      DEFEATED_DRAGON: "defeated_dragon",
+      // Moder
+      DEFEATED_GOBLINKING: "defeated_goblinking",
+      // Yagluth
+      DEFEATED_QUEEN: "defeated_queen",
+      KILLED_TROLL: "KilledTroll",
+      KILLED_BAT: "KilledBat",
+      KILLED_SURTLING: "KilledSurtling"
+    };
   }
 });
 
@@ -373,6 +458,415 @@ var init_client = __esm({
   }
 });
 
+// src/rcon/manager.ts
+var RconManager, rconManager;
+var init_manager = __esm({
+  "src/rcon/manager.ts"() {
+    "use strict";
+    init_client();
+    RconManager = class {
+      client = null;
+      config = null;
+      state = "disconnected";
+      reconnectTimer = null;
+      pollTimer = null;
+      reconnectAttempts = 0;
+      maxReconnectAttempts = 10;
+      reconnectDelay = 5e3;
+      // 5 seconds
+      pollInterval = 1e4;
+      // 10 seconds
+      onConnectionStateChange = null;
+      onPlayerListUpdate = null;
+      lastKnownPlayers = [];
+      enabled = false;
+      /**
+       * Initialize the RCON manager
+       * @param config RCON configuration
+       * @param options Optional callbacks and settings
+       */
+      initialize(config, options = {}) {
+        this.config = config;
+        this.enabled = config.enabled;
+        this.onConnectionStateChange = options.onConnectionStateChange ?? null;
+        this.onPlayerListUpdate = options.onPlayerListUpdate ?? null;
+        if (options.pollInterval) {
+          this.pollInterval = options.pollInterval;
+        }
+        if (this.enabled) {
+          this.connect();
+        }
+      }
+      /**
+       * Connect to RCON server
+       */
+      async connect() {
+        if (!this.config || !this.enabled) {
+          return false;
+        }
+        if (this.state === "connected" || this.state === "connecting") {
+          return true;
+        }
+        this.setState("connecting");
+        this.reconnectAttempts = 0;
+        try {
+          this.client = new RconClient({
+            host: "localhost",
+            port: this.config.port,
+            password: this.config.password,
+            timeout: this.config.timeout
+          });
+          await this.client.connect();
+          this.setState("connected");
+          this.reconnectAttempts = 0;
+          this.startPlayerListPolling();
+          return true;
+        } catch (_error) {
+          this.setState("error");
+          this.client = null;
+          if (this.config.autoReconnect && this.enabled) {
+            this.scheduleReconnect();
+          }
+          return false;
+        }
+      }
+      /**
+       * Disconnect from RCON server
+       */
+      disconnect() {
+        this.enabled = false;
+        this.clearTimers();
+        if (this.client) {
+          this.client.disconnect();
+          this.client = null;
+        }
+        this.setState("disconnected");
+        this.lastKnownPlayers = [];
+      }
+      /**
+       * Send a command to the RCON server
+       * @param command Command to send
+       * @returns Response from server, or null if not connected
+       */
+      async send(command) {
+        if (!this.client || this.state !== "connected") {
+          return null;
+        }
+        try {
+          const response = await this.client.send(command);
+          return response;
+        } catch (_error) {
+          this.setState("error");
+          if (this.config?.autoReconnect && this.enabled) {
+            this.scheduleReconnect();
+          }
+          return null;
+        }
+      }
+      /**
+       * Get the current player list from the server
+       * @returns Array of player names, or empty array if unavailable
+       */
+      async getPlayerList() {
+        const response = await this.send("status");
+        if (!response) {
+          return [];
+        }
+        const players = this.parsePlayerList(response);
+        return players;
+      }
+      /**
+       * Parse player names from status command response
+       * @param statusText Raw status response from server
+       * @returns Array of player names
+       */
+      parsePlayerList(statusText) {
+        const players = [];
+        const lines = statusText.split("\n");
+        for (const line of lines) {
+          if (line.includes("players:")) {
+            const match = line.match(/players:\s*(.+)/);
+            if (match?.[1]) {
+              const names = match[1].split(",").map((n) => n.trim()).filter((n) => n.length > 0);
+              players.push(...names);
+            }
+          }
+        }
+        return players;
+      }
+      /**
+       * Start polling for player list updates
+       */
+      startPlayerListPolling() {
+        this.stopPlayerListPolling();
+        this.pollTimer = setInterval(async () => {
+          if (this.state !== "connected") {
+            return;
+          }
+          const players = await this.getPlayerList();
+          if (this.hasPlayerListChanged(players)) {
+            this.lastKnownPlayers = players;
+            if (this.onPlayerListUpdate) {
+              this.onPlayerListUpdate(players);
+            }
+          }
+        }, this.pollInterval);
+      }
+      /**
+       * Stop polling for player list
+       */
+      stopPlayerListPolling() {
+        if (this.pollTimer) {
+          clearInterval(this.pollTimer);
+          this.pollTimer = null;
+        }
+      }
+      /**
+       * Check if player list has changed
+       */
+      hasPlayerListChanged(newPlayers) {
+        if (newPlayers.length !== this.lastKnownPlayers.length) {
+          return true;
+        }
+        const sorted1 = [...newPlayers].sort();
+        const sorted2 = [...this.lastKnownPlayers].sort();
+        return !sorted1.every((name, i) => name === sorted2[i]);
+      }
+      /**
+       * Schedule a reconnect attempt
+       */
+      scheduleReconnect() {
+        if (this.reconnectTimer) {
+          return;
+        }
+        if (this.reconnectAttempts >= this.maxReconnectAttempts) {
+          return;
+        }
+        this.reconnectAttempts++;
+        const delay = this.reconnectDelay * this.reconnectAttempts;
+        this.reconnectTimer = setTimeout(async () => {
+          this.reconnectTimer = null;
+          await this.connect();
+        }, delay);
+      }
+      /**
+       * Update the connection state and notify listeners
+       */
+      setState(newState) {
+        if (this.state === newState) {
+          return;
+        }
+        this.state = newState;
+        if (this.onConnectionStateChange) {
+          this.onConnectionStateChange(newState);
+        }
+      }
+      /**
+       * Clear all timers
+       */
+      clearTimers() {
+        if (this.reconnectTimer) {
+          clearTimeout(this.reconnectTimer);
+          this.reconnectTimer = null;
+        }
+        this.stopPlayerListPolling();
+      }
+      /**
+       * Get the current connection state
+       */
+      getState() {
+        return this.state;
+      }
+      /**
+       * Check if RCON is connected
+       */
+      isConnected() {
+        return this.state === "connected";
+      }
+      /**
+       * Get the last known player list
+       */
+      getLastKnownPlayers() {
+        return [...this.lastKnownPlayers];
+      }
+      /**
+       * Kick a player from the server
+       * @param playerName Player name to kick
+       * @returns Response message
+       */
+      async kickPlayer(playerName) {
+        return this.send(`kick ${playerName}`);
+      }
+      /**
+       * Ban a player from the server
+       * @param playerName Player name to ban
+       * @returns Response message
+       */
+      async banPlayer(playerName) {
+        return this.send(`ban ${playerName}`);
+      }
+      /**
+       * Unban a player
+       * @param playerName Player name to unban
+       * @returns Response message
+       */
+      async unbanPlayer(playerName) {
+        return this.send(`unban ${playerName}`);
+      }
+      /**
+       * Get list of banned players
+       * @returns Array of banned player names/IDs
+       */
+      async getBannedPlayers() {
+        const response = await this.send("banned");
+        if (!response) return [];
+        return response.split("\n").filter((line) => line.trim().length > 0);
+      }
+      /**
+       * Get server information
+       * @returns Server info response
+       */
+      async getServerInfo() {
+        return this.send("info");
+      }
+      /**
+       * Ping the server
+       * @returns Ping response
+       */
+      async pingServer() {
+        return this.send("ping");
+      }
+      /**
+       * Trigger a random event
+       * @param eventName Event name (e.g., "army_eikthyr")
+       * @returns Response message
+       */
+      async triggerEvent(eventName) {
+        return this.send(`event ${eventName}`);
+      }
+      /**
+       * Trigger a random event
+       * @returns Response message
+       */
+      async triggerRandomEvent() {
+        return this.send("randomevent");
+      }
+      /**
+       * Stop the current event
+       * @returns Response message
+       */
+      async stopEvent() {
+        return this.send("stopevent");
+      }
+      /**
+       * Skip time by specified seconds
+       * @param seconds Number of seconds to skip
+       * @returns Response message
+       */
+      async skipTime(seconds) {
+        return this.send(`skiptime ${seconds}`);
+      }
+      /**
+       * Sleep through the night
+       * @returns Response message
+       */
+      async sleep() {
+        return this.send("sleep");
+      }
+      /**
+       * Remove all dropped items from the world
+       * @returns Response message
+       */
+      async removeDrops() {
+        return this.send("removedrops");
+      }
+      /**
+       * Set a global key
+       * @param key Global key name
+       * @returns Response message
+       */
+      async setGlobalKey(key) {
+        return this.send(`setkey ${key}`);
+      }
+      /**
+       * Remove a global key
+       * @param key Global key name
+       * @returns Response message
+       */
+      async removeGlobalKey(key) {
+        return this.send(`removekey ${key}`);
+      }
+      /**
+       * Reset all global keys
+       * @returns Response message
+       */
+      async resetGlobalKeys() {
+        return this.send("resetkeys");
+      }
+      /**
+       * List all global keys
+       * @returns Array of global key names
+       */
+      async listGlobalKeys() {
+        const response = await this.send("listkeys");
+        if (!response) return [];
+        return response.split("\n").filter((line) => line.trim().length > 0);
+      }
+      /**
+       * Set LOD bias (0-5, lower = better performance)
+       * @param value LOD bias value
+       * @returns Response message
+       */
+      async setLodBias(value) {
+        return this.send(`lodbias ${value}`);
+      }
+      /**
+       * Set LOD distance (100-6000)
+       * @param value LOD distance value
+       * @returns Response message
+       */
+      async setLodDistance(value) {
+        return this.send(`loddist ${value}`);
+      }
+      /**
+       * Clean up resources
+       */
+      cleanup() {
+        this.disconnect();
+      }
+    };
+    rconManager = new RconManager();
+  }
+});
+
+// src/rcon/mod.ts
+var mod_exports = {};
+__export(mod_exports, {
+  PacketType: () => PacketType,
+  RconClient: () => RconClient,
+  RconError: () => RconError,
+  ValheimCommands: () => ValheimCommands,
+  ValheimEvents: () => ValheimEvents,
+  ValheimGlobalKeys: () => ValheimGlobalKeys,
+  createAuthPacket: () => createAuthPacket,
+  createCommandPacket: () => createCommandPacket,
+  decodePacket: () => decodePacket,
+  encodePacket: () => encodePacket,
+  isAuthFailure: () => isAuthFailure,
+  isAuthResponse: () => isAuthResponse,
+  isAuthSuccess: () => isAuthSuccess,
+  rconManager: () => rconManager
+});
+var init_mod = __esm({
+  "src/rcon/mod.ts"() {
+    "use strict";
+    init_client();
+    init_manager();
+    init_protocol();
+    init_types();
+  }
+});
+
 // src/cli/args.ts
 import { z } from "zod";
 var PortSchema = z.number().int().min(1024).max(65535);
@@ -919,11 +1413,11 @@ var defaultConfig = {
     refreshRate: 1e3
   },
   rcon: {
-    enabled: false,
+    enabled: true,
     port: 25575,
-    password: "",
+    password: "valheim-rcon",
     timeout: 5e3,
-    autoReconnect: false
+    autoReconnect: true
   },
   worlds: [],
   activeWorld: null,
@@ -1026,11 +1520,11 @@ var TuiConfigSchema = z2.object({
   refreshRate: z2.number().int().min(100).max(5e3).default(1e3)
 });
 var RconConfigSchema = z2.object({
-  enabled: z2.boolean().default(false),
+  enabled: z2.boolean().default(true),
   port: z2.number().int().min(1024, "Port must be >= 1024").max(65535, "Port must be <= 65535").default(25575),
-  password: z2.string().default(""),
+  password: z2.string().default("valheim-rcon"),
   timeout: z2.number().int().min(1e3).max(6e4).default(5e3),
-  autoReconnect: z2.boolean().default(false)
+  autoReconnect: z2.boolean().default(true)
 });
 var AppConfigSchema = z2.object({
   version: z2.number().int().default(1),
@@ -2496,13 +2990,7 @@ function createProgressBar(percent) {
 
 // src/cli/commands/rcon.ts
 import * as readline from "readline";
-
-// src/rcon/mod.ts
-init_client();
-init_protocol();
-init_types();
-
-// src/cli/commands/rcon.ts
+init_mod();
 async function rconCommand(args) {
   const config = await loadConfig();
   const host = args.host ?? "localhost";
@@ -2640,10 +3128,30 @@ async function interactiveRcon(args) {
 }
 
 // src/server/commands.ts
+init_mod();
 import * as fs5 from "fs/promises";
 import { dirname, join } from "path";
 
 // src/server/logs.ts
+function parseLogLine(line) {
+  const timestamp = /* @__PURE__ */ new Date();
+  let level = "info";
+  let message = line.trim();
+  if (line.includes("Error") || line.includes("Exception")) {
+    level = "error";
+  } else if (line.includes("Warning") || line.includes("WARN")) {
+    level = "warn";
+  } else if (line.includes("DEBUG") || line.includes("[Debug]")) {
+    level = "debug";
+  }
+  const timestampMatch = line.match(
+    /^(\d{2}\/\d{2}\/\d{4} \d{2}:\d{2}:\d{2}): (.+)$/
+  );
+  if (timestampMatch) {
+    message = timestampMatch[2];
+  }
+  return { timestamp, level, message, raw: line };
+}
 function parseEvent(line) {
   if (line.includes("Got character ZDOID from")) {
     const match = line.match(/Got character ZDOID from (\S+)/);
@@ -2651,8 +3159,11 @@ function parseEvent(line) {
       return { type: "player_join", name: match[1] };
     }
   }
-  if (line.includes("Closing socket")) {
-    return null;
+  if (line.includes("Destroying abandoned non persistent zdo")) {
+    const playerMatch = line.match(/owner (\S+)/);
+    if (playerMatch?.[1]) {
+      return { type: "player_leave", name: playerMatch[1] };
+    }
   }
   if (line.includes("World saved")) {
     return { type: "world_saved" };
@@ -2690,9 +3201,179 @@ function parseEvent(line) {
   return null;
 }
 
+// src/server/logTail.ts
+import { open } from "fs/promises";
+var LogTailer = class {
+  filePath;
+  handle = null;
+  position = 0;
+  running = false;
+  pollInterval = null;
+  buffer = "";
+  onLine;
+  onEvent;
+  pollMs;
+  /**
+   * Creates a new log tailer
+   * @param filePath Path to the log file to tail
+   * @param onLine Callback for each new log line
+   * @param options Optional settings
+   */
+  constructor(filePath, onLine, options) {
+    this.filePath = filePath;
+    this.onLine = onLine;
+    this.onEvent = options?.onEvent;
+    this.pollMs = options?.pollMs ?? 500;
+  }
+  /**
+   * Starts tailing the log file
+   * @param fromEnd If true, start from end of file (skip existing content)
+   */
+  async start(fromEnd = true) {
+    if (this.running) return;
+    try {
+      this.handle = await open(this.filePath, "r");
+      if (fromEnd) {
+        const stats = await this.handle.stat();
+        this.position = stats.size;
+      } else {
+        this.position = 0;
+      }
+      this.running = true;
+      this.pollInterval = setInterval(() => this.poll(), this.pollMs);
+      await this.poll();
+    } catch (_error) {
+      this.running = true;
+      this.pollInterval = setInterval(() => this.poll(), this.pollMs);
+    }
+  }
+  /**
+   * Stops tailing the log file
+   */
+  async stop() {
+    this.running = false;
+    if (this.pollInterval) {
+      clearInterval(this.pollInterval);
+      this.pollInterval = null;
+    }
+    if (this.handle) {
+      await this.handle.close();
+      this.handle = null;
+    }
+  }
+  /**
+   * Polls the log file for new content
+   */
+  async poll() {
+    if (!this.running) return;
+    try {
+      if (!this.handle) {
+        try {
+          this.handle = await open(this.filePath, "r");
+          const stats2 = await this.handle.stat();
+          if (this.position > stats2.size) {
+            this.position = 0;
+          }
+        } catch {
+          return;
+        }
+      }
+      const stats = await this.handle.stat();
+      if (stats.size <= this.position) {
+        if (stats.size < this.position) {
+          this.position = 0;
+        }
+        return;
+      }
+      const bytesToRead = stats.size - this.position;
+      const buffer = Buffer.alloc(bytesToRead);
+      const { bytesRead } = await this.handle.read(
+        buffer,
+        0,
+        bytesToRead,
+        this.position
+      );
+      if (bytesRead > 0) {
+        this.position += bytesRead;
+        this.processChunk(buffer.toString("utf-8", 0, bytesRead));
+      }
+    } catch (_error) {
+      if (this.handle) {
+        try {
+          await this.handle.close();
+        } catch {
+        }
+        this.handle = null;
+      }
+    }
+  }
+  /**
+   * Processes a chunk of log data, splitting into lines
+   */
+  processChunk(chunk) {
+    this.buffer += chunk;
+    const lines = this.buffer.split("\n");
+    this.buffer = lines.pop() ?? "";
+    for (const line of lines) {
+      const trimmed = line.trim();
+      if (!trimmed) continue;
+      const entry = parseLogLine(trimmed);
+      this.onLine(trimmed, entry);
+      const event = parseEvent(trimmed);
+      if (event && this.onEvent) {
+        this.onEvent(event);
+      }
+    }
+  }
+  /**
+   * Reads the last N lines from the log file (for initial display)
+   * @param lineCount Number of lines to read
+   * @returns Array of log entries
+   */
+  async readLastLines(lineCount = 100) {
+    const entries = [];
+    try {
+      const handle = await open(this.filePath, "r");
+      const stats = await handle.stat();
+      const fileSize = stats.size;
+      const chunkSize = Math.min(16384, fileSize);
+      let position = Math.max(0, fileSize - chunkSize);
+      let content = "";
+      let lines = [];
+      while (lines.length < lineCount && position >= 0) {
+        const buffer = Buffer.alloc(Math.min(chunkSize, fileSize - position));
+        await handle.read(buffer, 0, buffer.length, position);
+        content = buffer.toString("utf-8") + content;
+        lines = content.split("\n").filter((l) => l.trim());
+        if (position === 0) break;
+        position = Math.max(0, position - chunkSize);
+      }
+      await handle.close();
+      const lastLines = lines.slice(-lineCount);
+      for (const line of lastLines) {
+        entries.push(parseLogLine(line.trim()));
+      }
+    } catch {
+    }
+    return entries;
+  }
+  /** Whether the tailer is currently running */
+  get isRunning() {
+    return this.running;
+  }
+};
+
 // src/server/pidfile.ts
 import fs6 from "fs/promises";
 import path5 from "path";
+function getServerLogsDir() {
+  return path5.join(getAppConfigDir(), "logs");
+}
+function getServerLogFile(timestamp) {
+  const ts = timestamp ?? /* @__PURE__ */ new Date();
+  const dateStr = ts.toISOString().split("T")[0];
+  return path5.join(getServerLogsDir(), `valheim-server-${dateStr}.log`);
+}
 function getPidFilePath() {
   return path5.join(getConfigDir(), "oz-valheim", "server.pid");
 }
@@ -2746,9 +3427,28 @@ async function getRunningServer() {
   }
   return data;
 }
+async function ensureLogsDir() {
+  const logsDir = getServerLogsDir();
+  await fs6.mkdir(logsDir, { recursive: true });
+}
+async function cleanupOldLogs(keepCount = 7) {
+  const logsDir = getServerLogsDir();
+  try {
+    const files = await fs6.readdir(logsDir);
+    const logFiles = files.filter((f) => f.startsWith("valheim-server-") && f.endsWith(".log")).sort().reverse();
+    for (const file of logFiles.slice(keepCount)) {
+      try {
+        await fs6.unlink(path5.join(logsDir, file));
+      } catch {
+      }
+    }
+  } catch {
+  }
+}
 
 // src/server/process.ts
 import { spawn } from "child_process";
+import { createWriteStream } from "fs";
 var defaultEvents = {
   onStateChange: () => {
   },
@@ -2767,6 +3467,12 @@ var ValheimProcess = class {
   events;
   config;
   startTime = null;
+  logFileStream = null;
+  logTailer = null;
+  _logFilePath = null;
+  _isDetached = false;
+  /** PID for detached processes (when we don't have a direct handle) */
+  _detachedPid = null;
   /**
    * Creates a new Valheim process wrapper
    * @param config Server launch configuration
@@ -2778,7 +3484,7 @@ var ValheimProcess = class {
   }
   /** Gets the process ID if running, null otherwise */
   get pid() {
-    return this.process?.pid ?? null;
+    return this.process?.pid ?? this._detachedPid ?? null;
   }
   /** Gets the current process state */
   get currentState() {
@@ -2788,6 +3494,14 @@ var ValheimProcess = class {
   get uptime() {
     return this.startTime;
   }
+  /** Gets the log file path (for detached mode) */
+  get logFilePath() {
+    return this._logFilePath;
+  }
+  /** Whether the server is running in detached mode */
+  get isDetached() {
+    return this._isDetached;
+  }
   /**
    * Updates the process state and notifies listeners
    * @param newState New process state
@@ -2806,21 +3520,16 @@ var ValheimProcess = class {
     }
     this.setState("starting");
     this.startTime = /* @__PURE__ */ new Date();
+    this._isDetached = this.config.detached ?? false;
     const execPath = getValheimExecutablePath();
     const args = this.buildArgs();
     const env = this.getEnvironment();
     try {
-      this.process = spawn(execPath, args, {
-        stdio: ["ignore", "pipe", "pipe"],
-        env
-      });
-      this.streamOutput();
-      this.process.on("error", (error2) => {
-        this.setState("crashed");
-        this.startTime = null;
-        this.events.onError(error2);
-      });
-      await Promise.resolve();
+      if (this._isDetached) {
+        await this.startDetached(execPath, args, env);
+      } else {
+        await this.startAttached(execPath, args, env);
+      }
     } catch (error2) {
       this.setState("crashed");
       this.startTime = null;
@@ -2828,6 +3537,169 @@ var ValheimProcess = class {
       throw error2;
     }
   }
+  /**
+   * Starts the server in attached mode (piped stdout/stderr)
+   */
+  async startAttached(execPath, args, env) {
+    this.process = spawn(execPath, args, {
+      stdio: ["ignore", "pipe", "pipe"],
+      env
+    });
+    this.streamOutput();
+    this.process.on("error", (error2) => {
+      this.setState("crashed");
+      this.startTime = null;
+      this.events.onError(error2);
+    });
+    await Promise.resolve();
+  }
+  /**
+   * Starts the server in detached mode (log file output, independent process)
+   */
+  async startDetached(execPath, args, env) {
+    await ensureLogsDir();
+    this._logFilePath = getServerLogFile(this.startTime);
+    this.logFileStream = createWriteStream(this._logFilePath, { flags: "a" });
+    const header = `
+${"=".repeat(60)}
+Server starting at ${this.startTime.toISOString()}
+World: ${this.config.world} | Port: ${this.config.port}
+${"=".repeat(60)}
+`;
+    this.logFileStream.write(header);
+    const platform = getPlatform();
+    this.process = spawn(execPath, args, {
+      stdio: ["ignore", "pipe", "pipe"],
+      env,
+      detached: true
+    });
+    if (this.process.stdout) {
+      this.process.stdout.pipe(this.logFileStream, { end: false });
+    }
+    if (this.process.stderr) {
+      this.process.stderr.pipe(this.logFileStream, { end: false });
+    }
+    this.logTailer = new LogTailer(
+      this._logFilePath,
+      (line, _entry) => {
+        this.events.onLog(line);
+      },
+      {
+        onEvent: (event) => this.handleEvent(event),
+        fromEnd: false
+        // Read from where we started
+      }
+    );
+    await this.logTailer.start(false);
+    this.process.on("error", (error2) => {
+      this.setState("crashed");
+      this.startTime = null;
+      this.events.onError(error2);
+    });
+    const pid = this.process.pid;
+    if (pid) {
+      await writePidFile({
+        pid,
+        startedAt: this.startTime.toISOString(),
+        world: this.config.world,
+        port: this.config.port,
+        logFile: this._logFilePath,
+        detached: true,
+        serverName: this.config.name
+      });
+    }
+    this.process.unref();
+    if (platform === "windows") {
+      if (this.process.stdout && typeof this.process.stdout.unref === "function") {
+        this.process.stdout.unref();
+      }
+      if (this.process.stderr && typeof this.process.stderr.unref === "function") {
+        this.process.stderr.unref();
+      }
+    }
+    this.process.on("exit", (code, signal) => {
+      const exitCode = code ?? (signal ? 1 : 0);
+      if (exitCode !== 0 && (this.state === "online" || this.state === "starting")) {
+        this.startTime = null;
+        this.setState("crashed");
+        this.events.onError(new Error(`Server exited with code ${exitCode}`));
+      }
+    });
+    await Promise.resolve();
+  }
+  /**
+   * Handles a parsed event from log output
+   */
+  handleEvent(event) {
+    this.events.onEvent?.(event);
+    switch (event.type) {
+      case "player_join":
+        this.events.onPlayerJoin(event.name);
+        break;
+      case "player_leave":
+        this.events.onPlayerLeave(event.name);
+        break;
+      case "server_ready":
+        if (this.state === "starting") {
+          this.setState("online");
+        }
+        break;
+      case "error":
+        this.events.onError(new Error(event.message));
+        break;
+    }
+  }
+  /**
+   * Attaches to an already-running detached server
+   * @param pidData PID file data for the running server
+   */
+  async attach(pidData) {
+    if (this.state !== "offline" && this.state !== "crashed") {
+      throw new Error(`Cannot attach in state: ${this.state}`);
+    }
+    if (!isProcessRunning(pidData.pid)) {
+      throw new Error(`Server process ${pidData.pid} is not running`);
+    }
+    this._isDetached = true;
+    this._detachedPid = pidData.pid;
+    this._logFilePath = pidData.logFile ?? null;
+    this.startTime = new Date(pidData.startedAt);
+    if (this._logFilePath) {
+      this.logTailer = new LogTailer(
+        this._logFilePath,
+        (line, _entry) => {
+          this.events.onLog(line);
+        },
+        {
+          onEvent: (event) => this.handleEvent(event),
+          pollMs: 500
+        }
+      );
+      const history = await this.logTailer.readLastLines(50);
+      for (const entry of history) {
+        this.events.onLog(entry.raw);
+      }
+      await this.logTailer.start(true);
+    }
+    this.startProcessMonitor();
+    this.setState("online");
+  }
+  /**
+   * Monitors a detached process for exit
+   */
+  startProcessMonitor() {
+    const checkInterval = setInterval(() => {
+      const pid = this._detachedPid;
+      if (pid && !isProcessRunning(pid)) {
+        clearInterval(checkInterval);
+        this._detachedPid = null;
+        this.startTime = null;
+        this.setState("crashed");
+        this.events.onError(new Error("Server process exited unexpectedly"));
+      }
+    }, 2e3);
+    this._monitorInterval = checkInterval;
+  }
   /**
    * Gracefully stops the server with optional timeout
    * @param timeout Maximum time to wait for graceful shutdown (ms)
@@ -2837,6 +3709,31 @@ var ValheimProcess = class {
       return;
     }
     this.setState("stopping");
+    await this.cleanup();
+    if (this._isDetached && this._detachedPid) {
+      const platform = getPlatform();
+      try {
+        process.kill(this._detachedPid, "SIGTERM");
+      } catch {
+      }
+      const startTime = Date.now();
+      while (isProcessRunning(this._detachedPid) && Date.now() - startTime < timeout) {
+        await new Promise((resolve) => setTimeout(resolve, 500));
+      }
+      if (isProcessRunning(this._detachedPid)) {
+        try {
+          process.kill(
+            this._detachedPid,
+            platform === "windows" ? "SIGTERM" : "SIGKILL"
+          );
+        } catch {
+        }
+      }
+      this._detachedPid = null;
+      this.startTime = null;
+      this.setState("offline");
+      return;
+    }
     if (this.process) {
       try {
         this.process.kill("SIGTERM");
@@ -2864,6 +3761,18 @@ var ValheimProcess = class {
    * Immediately kills the server process
    */
   async kill() {
+    await this.cleanup();
+    if (this._isDetached && this._detachedPid) {
+      const platform = getPlatform();
+      try {
+        process.kill(
+          this._detachedPid,
+          platform === "windows" ? "SIGTERM" : "SIGKILL"
+        );
+      } catch {
+      }
+      this._detachedPid = null;
+    }
     if (this.process) {
       try {
         this.process.kill("SIGKILL");
@@ -2875,6 +3784,36 @@ var ValheimProcess = class {
     this.setState("offline");
     await Promise.resolve();
   }
+  /**
+   * Detaches from a running server without stopping it
+   * Only valid for servers started in detached mode
+   */
+  async detach() {
+    if (!this._isDetached) {
+      throw new Error("Cannot detach from non-detached server");
+    }
+    await this.cleanup();
+    this.process = null;
+    this._detachedPid = null;
+  }
+  /**
+   * Cleans up resources (log tailer, monitor interval, log file stream)
+   */
+  async cleanup() {
+    const self = this;
+    if (self._monitorInterval) {
+      clearInterval(self._monitorInterval);
+      self._monitorInterval = void 0;
+    }
+    if (this.logTailer) {
+      await this.logTailer.stop();
+      this.logTailer = null;
+    }
+    if (this.logFileStream) {
+      this.logFileStream.end();
+      this.logFileStream = null;
+    }
+  }
   /**
    * Builds command line arguments for Valheim server
    * @returns Array of command line arguments
@@ -3190,6 +4129,18 @@ async function startCommand(args, config) {
     console.log("Run 'valheim-dsm install' first to install the server.");
     process.exit(1);
   }
+  const running = await getRunningServer();
+  if (running) {
+    console.error(`
+Error: A server is already running.`);
+    console.log(`  PID: ${running.pid}`);
+    console.log(`  World: ${running.world}`);
+    console.log(`  Port: ${running.port}`);
+    console.log(`  Started: ${new Date(running.startedAt).toLocaleString()}`);
+    console.log("\nRun 'valheim-dsm stop' to stop it first.");
+    process.exit(1);
+  }
+  await cleanupOldLogs();
   const serverConfig = {
     name: args.name ?? config.server.name,
     port: args.port ?? config.server.port,
@@ -3199,7 +4150,9 @@ async function startCommand(args, config) {
     crossplay: args.crossplay ?? config.server.crossplay,
     savedir: args.savedir ?? config.server.savedir,
     saveinterval: config.server.saveinterval,
-    backups: config.server.backups
+    backups: config.server.backups,
+    // Always use detached mode for stability
+    detached: true
   };
   console.log(`
 Starting ${serverConfig.name}...`);
@@ -3207,6 +4160,7 @@ Starting ${serverConfig.name}...`);
   console.log(`  Port: ${serverConfig.port}`);
   console.log(`  Public: ${serverConfig.public}`);
   console.log(`  Crossplay: ${serverConfig.crossplay}`);
+  console.log(`  Mode: Detached (server continues after terminal exits)`);
   console.log("");
   activeWatchdog = new Watchdog(
     serverConfig,
@@ -3220,6 +4174,12 @@ Starting ${serverConfig.name}...`);
     {
       onStateChange: (state) => {
         console.log(`[Server] State: ${state}`);
+        if (state === "online") {
+          console.log("\n\u2713 Server is now online!");
+          console.log("  The server will continue running in the background.");
+          console.log("  Use 'valheim-dsm stop' to stop it.");
+          console.log("  Use 'valheim-dsm' (TUI) to manage it.\n");
+        }
       },
       onLog: (line) => {
         console.log(`[Server] ${line}`);
@@ -3248,18 +4208,34 @@ Starting ${serverConfig.name}...`);
   setupShutdownHandlers();
   try {
     await activeWatchdog.start();
-    const pid = activeWatchdog.serverProcess.pid;
-    if (pid) {
-      await writePidFile({
-        pid,
-        startedAt: (/* @__PURE__ */ new Date()).toISOString(),
-        world: serverConfig.world,
-        port: serverConfig.port
-      });
+    const logPath = activeWatchdog.serverProcess.logFilePath;
+    if (logPath) {
+      console.log(`
+Server log: ${logPath}`);
     }
-    console.log("\nServer started. Press Ctrl+C to stop.\n");
-    await new Promise(() => {
-    });
+    console.log("\nServer is starting in detached mode.");
+    console.log(
+      "Press Ctrl+C to stop monitoring (server will keep running).\n"
+    );
+    const timeout = 12e4;
+    const startTime = Date.now();
+    while (Date.now() - startTime < timeout) {
+      const state = activeWatchdog.serverProcess.currentState;
+      if (state === "online") {
+        await new Promise((resolve) => setTimeout(resolve, 2e3));
+        break;
+      }
+      if (state === "crashed" || state === "offline") {
+        console.error("\nServer failed to start.");
+        await cleanupAndExit(1);
+        return;
+      }
+      await new Promise((resolve) => setTimeout(resolve, 1e3));
+    }
+    console.log("\nDetaching from server...");
+    await activeWatchdog.serverProcess.detach();
+    activeWatchdog = null;
+    process.exit(0);
   } catch (error2) {
     console.error(`
 Failed to start server: ${error2.message}`);
@@ -3272,14 +4248,26 @@ function getActiveWatchdog() {
 function clearActiveWatchdog() {
   activeWatchdog = null;
 }
+async function cleanupAndExit(code) {
+  if (activeWatchdog) {
+    try {
+      await activeWatchdog.serverProcess.detach();
+    } catch {
+    }
+    activeWatchdog = null;
+  }
+  process.exit(code);
+}
 function setupShutdownHandlers() {
   const shutdown = async () => {
-    console.log("\n\nShutting down...");
+    console.log("\n\nDetaching from server (it will keep running)...");
     if (activeWatchdog) {
-      await activeWatchdog.stop();
+      try {
+        await activeWatchdog.serverProcess.detach();
+      } catch {
+      }
       activeWatchdog = null;
     }
-    await removePidFile();
     process.exit(0);
   };
   process.on("SIGINT", shutdown);
@@ -3290,9 +4278,9 @@ function setupShutdownHandlers() {
 
 // src/cli/commands/stop.ts
 async function stopCommand(args) {
+  const timeout = args.timeout ?? 3e4;
   const watchdog2 = getActiveWatchdog();
   if (watchdog2) {
-    const timeout = args.timeout ?? 3e4;
     if (args.force) {
       console.log("\nForce stopping server...");
       await watchdog2.kill();
@@ -3312,34 +4300,53 @@ Stopping server (timeout: ${timeout}ms)...`);
     console.log("\nNote: Run 'valheim-dsm start' to start a server.");
     return;
   }
-  const { pid, world, port, startedAt } = runningServer;
+  const { pid, world, port, startedAt, detached, logFile } = runningServer;
   console.log(`
 Found running server:`);
   console.log(`  PID: ${pid}`);
   console.log(`  World: ${world}`);
   console.log(`  Port: ${port}`);
   console.log(`  Started: ${new Date(startedAt).toLocaleString()}`);
+  console.log(`  Mode: ${detached ? "Detached" : "Attached"}`);
+  if (logFile) {
+    console.log(`  Log: ${logFile}`);
+  }
   if (!isProcessRunning(pid)) {
     console.log("\nServer process is no longer running. Cleaning up...");
     await removePidFile();
     return;
   }
+  const platform = getPlatform();
   if (args.force) {
     console.log("\nForce killing server...");
-    killProcess(pid, true);
+    killProcess(pid, platform !== "windows");
   } else {
     console.log("\nSending stop signal...");
     killProcess(pid, false);
-    const timeout = args.timeout ?? 3e4;
     const startTime = Date.now();
+    let dots = 0;
     while (isProcessRunning(pid) && Date.now() - startTime < timeout) {
       await new Promise((resolve) => setTimeout(resolve, 500));
       process.stdout.write(".");
+      dots++;
     }
-    console.log();
+    if (dots > 0) console.log();
     if (isProcessRunning(pid)) {
       console.log("Server did not stop gracefully, force killing...");
-      killProcess(pid, true);
+      killProcess(pid, platform !== "windows");
+      await new Promise((resolve) => setTimeout(resolve, 2e3));
+      if (isProcessRunning(pid)) {
+        console.error(
+          "Failed to stop server. Process may require manual termination."
+        );
+        console.log(`  PID: ${pid}`);
+        if (platform === "windows") {
+          console.log(`  Try: taskkill /F /PID ${pid}`);
+        } else {
+          console.log(`  Try: kill -9 ${pid}`);
+        }
+        return;
+      }
     }
   }
   await removePidFile();
@@ -3853,13 +4860,16 @@ Error deleting world: ${error2.message}`);
   }
 }
 
+// src/mod.ts
+init_mod();
+
 // src/tui/mod.ts
 import { withFullScreen } from "fullscreen-ink";
 import React2 from "react";
 
 // src/tui/App.tsx
-import { Box as Box17, useApp, useInput as useInput10 } from "ink";
-import { useEffect as useEffect12 } from "react";
+import { Box as Box22, useApp, useInput as useInput15 } from "ink";
+import { useEffect as useEffect14 } from "react";
 
 // src/tui/components/Header.tsx
 import { Box as Box2, Text as Text2 } from "ink";
@@ -3868,7 +4878,7 @@ import { useEffect as useEffect3, useMemo as useMemo2, useRef as useRef2, useSta
 // package.json
 var package_default = {
   name: "valheim-oz-dsm",
-  version: "1.5.4",
+  version: "1.8.0",
   description: "Land of OZ - Valheim Dedicated Server Manager",
   type: "module",
   bin: {
@@ -3877,7 +4887,6 @@ var package_default = {
   main: "./dist/main.js",
   files: [
     "dist",
-    "patches",
     "README.md",
     "LICENSE",
     "CHANGELOG.md"
@@ -3898,12 +4907,11 @@ var package_default = {
     "lint:fix": "biome check --write .",
     format: "biome format --write .",
     typecheck: "tsc --noEmit",
-    postinstall: "patch-package",
     prepare: "tsx scripts/install-hooks.ts",
     prepublishOnly: "npm run typecheck && npm run lint && npm test && npm run build"
   },
   dependencies: {
-    "@caleb-collar/steamcmd": "^1.1.0",
+    "@caleb-collar/steamcmd": "^1.1.1",
     conf: "^13.0.1",
     "fullscreen-ink": "^0.1.0",
     ink: "^6.6.0",
@@ -3916,7 +4924,6 @@ var package_default = {
     "@types/node": "^22.13.1",
     "@types/react": "^19.2.10",
     "@vitest/coverage-v8": "^3.2.4",
-    "patch-package": "^8.0.1",
     tsup: "^8.3.6",
     tsx: "^4.19.2",
     typescript: "^5.7.3",
@@ -4038,13 +5045,13 @@ var useStore = create((set) => ({
   },
   // Initial RCON state
   rcon: {
-    enabled: false,
+    enabled: true,
     connected: false,
     port: 25575,
-    password: "",
+    password: "valheim-rcon",
     host: "localhost",
     timeout: 5e3,
-    autoReconnect: false
+    autoReconnect: true
   },
   // Initial worlds state
   worlds: {
@@ -4093,6 +5100,9 @@ var useStore = create((set) => ({
         players: state.server.players.filter((p) => p !== name)
       }
     })),
+    setPlayers: (players) => set((state) => ({
+      server: { ...state.server, players }
+    })),
     incrementUptime: () => set((state) => ({
       server: { ...state.server, uptime: state.server.uptime + 1 }
     })),
@@ -42985,22 +43995,328 @@ var Console = () => {
 };
 
 // src/tui/screens/Dashboard.tsx
-import { Box as Box11, Text as Text11, useInput as useInput4 } from "ink";
-import { useEffect as useEffect7, useState as useState6 } from "react";
+import { Box as Box16, Text as Text16, useInput as useInput9 } from "ink";
+import { useEffect as useEffect9, useState as useState11 } from "react";
 
-// src/tui/components/Modal.tsx
+// src/tui/components/EventManager.tsx
+init_mod();
 import { Box as Box9, Text as Text9, useInput as useInput3 } from "ink";
+import { useState as useState5 } from "react";
 import { jsx as jsx9, jsxs as jsxs8 } from "react/jsx-runtime";
+var EVENT_LIST = [
+  {
+    key: ValheimEvents.ARMY_EIKTHYR,
+    name: "Eikthyr Army",
+    description: "Eikthyr rallies the creatures"
+  },
+  {
+    key: ValheimEvents.ARMY_THEELDER,
+    name: "The Elder's Hunt",
+    description: "The Elder is hunting you"
+  },
+  {
+    key: ValheimEvents.ARMY_BONEMASS,
+    name: "Bonemass Army",
+    description: "A foul smell from the swamp"
+  },
+  {
+    key: ValheimEvents.ARMY_MODER,
+    name: "Moder's Hunt",
+    description: "You are being hunted"
+  },
+  {
+    key: ValheimEvents.ARMY_GOBLIN,
+    name: "Goblin Horde",
+    description: "The horde is attacking"
+  },
+  {
+    key: ValheimEvents.FORESTTROLLS,
+    name: "Forest Trolls",
+    description: "The forest is moving"
+  },
+  {
+    key: ValheimEvents.SKELETONS,
+    name: "Skeletons",
+    description: "Skeleton surprise"
+  },
+  {
+    key: ValheimEvents.BLOBS,
+    name: "Blobs",
+    description: "Blob attack"
+  },
+  {
+    key: ValheimEvents.WOLVES,
+    name: "Wolves",
+    description: "You are being hunted"
+  },
+  {
+    key: ValheimEvents.BATS,
+    name: "Bats",
+    description: "Bat swarm"
+  },
+  {
+    key: ValheimEvents.SERPENTS,
+    name: "Serpents",
+    description: "Sea serpents"
+  }
+];
+var EventManager = ({ onClose }) => {
+  const rconConnected = useStore((s) => s.rcon.connected);
+  const addLog = useStore((s) => s.actions.addLog);
+  const [selectedIndex, setSelectedIndex] = useState5(0);
+  const handleTriggerEvent = async (eventKey, eventName) => {
+    const response = await rconManager.triggerEvent(eventKey);
+    if (response) {
+      addLog("info", `Triggered event: ${eventName}`);
+    } else {
+      addLog("error", `Failed to trigger event: ${eventName}`);
+    }
+  };
+  const handleRandomEvent = async () => {
+    const response = await rconManager.triggerRandomEvent();
+    if (response) {
+      addLog("info", `Triggered random event: ${response}`);
+    } else {
+      addLog("error", "Failed to trigger random event");
+    }
+  };
+  const handleStopEvent = async () => {
+    const response = await rconManager.stopEvent();
+    if (response) {
+      addLog("info", `Stopped event: ${response}`);
+    } else {
+      addLog("error", "Failed to stop event");
+    }
+  };
+  useInput3((input, key) => {
+    if (key.escape || input === "q" || input === "Q") {
+      onClose();
+      return;
+    }
+    if (key.upArrow) {
+      setSelectedIndex(Math.max(0, selectedIndex - 1));
+    } else if (key.downArrow) {
+      setSelectedIndex(Math.min(EVENT_LIST.length - 1, selectedIndex + 1));
+    }
+    if (key.return) {
+      const selectedEvent = EVENT_LIST[selectedIndex];
+      handleTriggerEvent(selectedEvent.key, selectedEvent.name);
+    } else if (input === "r" || input === "R") {
+      handleRandomEvent();
+    } else if (input === "x" || input === "X") {
+      handleStopEvent();
+    }
+  });
+  if (!rconConnected) {
+    return /* @__PURE__ */ jsxs8(
+      Box9,
+      {
+        flexDirection: "column",
+        borderStyle: "round",
+        borderColor: theme.error,
+        padding: 1,
+        width: 60,
+        children: [
+          /* @__PURE__ */ jsx9(Box9, { marginBottom: 1, children: /* @__PURE__ */ jsx9(Text9, { bold: true, color: theme.error, children: "\u26A0 Event Manager" }) }),
+          /* @__PURE__ */ jsx9(Text9, { dimColor: true, children: "RCON not connected" }),
+          /* @__PURE__ */ jsx9(Text9, { dimColor: true, children: "Event management requires RCON connection" }),
+          /* @__PURE__ */ jsx9(Box9, { marginTop: 1, children: /* @__PURE__ */ jsx9(Text9, { dimColor: true, children: "[Esc/Q] Close" }) })
+        ]
+      }
+    );
+  }
+  return /* @__PURE__ */ jsxs8(
+    Box9,
+    {
+      flexDirection: "column",
+      borderStyle: "round",
+      borderColor: theme.primary,
+      padding: 1,
+      width: 70,
+      height: 25,
+      children: [
+        /* @__PURE__ */ jsx9(Box9, { marginBottom: 1, children: /* @__PURE__ */ jsx9(Text9, { bold: true, color: theme.primary, children: "Event Manager" }) }),
+        /* @__PURE__ */ jsx9(Box9, { marginBottom: 1, children: /* @__PURE__ */ jsx9(Text9, { dimColor: true, children: "Use \u2191\u2193 to select, [Enter] Trigger, [R] Random, [X] Stop" }) }),
+        /* @__PURE__ */ jsx9(Box9, { flexDirection: "column", flexGrow: 1, children: EVENT_LIST.map((event, index) => /* @__PURE__ */ jsxs8(Box9, { marginLeft: 1, children: [
+          /* @__PURE__ */ jsxs8(
+            Text9,
+            {
+              color: index === selectedIndex ? theme.primary : theme.secondary,
+              bold: index === selectedIndex,
+              children: [
+                index === selectedIndex ? "\u2192 " : "  ",
+                event.name
+              ]
+            }
+          ),
+          /* @__PURE__ */ jsxs8(Text9, { dimColor: true, children: [
+            " - ",
+            event.description
+          ] })
+        ] }, event.key)) }),
+        /* @__PURE__ */ jsxs8(Box9, { marginTop: 1, flexDirection: "column", children: [
+          /* @__PURE__ */ jsx9(Text9, { dimColor: true, children: "[Enter] Trigger Selected" }),
+          /* @__PURE__ */ jsx9(Text9, { dimColor: true, children: "[R] Random Event [X] Stop Event" }),
+          /* @__PURE__ */ jsx9(Text9, { dimColor: true, children: "[Esc/Q] Close" })
+        ] })
+      ]
+    }
+  );
+};
+
+// src/tui/components/GlobalKeysManager.tsx
+init_mod();
+import { Box as Box10, Text as Text10, useInput as useInput4 } from "ink";
+import { useEffect as useEffect5, useState as useState6 } from "react";
+import { Fragment, jsx as jsx10, jsxs as jsxs9 } from "react/jsx-runtime";
+var BOSS_KEYS = [
+  { key: ValheimGlobalKeys.DEFEATED_EIKTHYR, name: "Eikthyr" },
+  { key: ValheimGlobalKeys.DEFEATED_GDKING, name: "The Elder" },
+  { key: ValheimGlobalKeys.DEFEATED_BONEMASS, name: "Bonemass" },
+  { key: ValheimGlobalKeys.DEFEATED_DRAGON, name: "Moder" },
+  { key: ValheimGlobalKeys.DEFEATED_GOBLINKING, name: "Yagluth" },
+  { key: ValheimGlobalKeys.DEFEATED_QUEEN, name: "The Queen" }
+];
+var GlobalKeysManager = ({ onClose }) => {
+  const rconConnected = useStore((s) => s.rcon.connected);
+  const addLog = useStore((s) => s.actions.addLog);
+  const [selectedIndex, setSelectedIndex] = useState6(0);
+  const [activeKeys, setActiveKeys] = useState6([]);
+  const [loading, setLoading] = useState6(true);
+  useEffect5(() => {
+    const loadKeys = async () => {
+      setLoading(true);
+      const keys = await rconManager.listGlobalKeys();
+      setActiveKeys(keys);
+      setLoading(false);
+    };
+    if (rconConnected) {
+      loadKeys();
+    }
+  }, [rconConnected]);
+  const isBossDefeated = (bossKey) => {
+    return activeKeys.some(
+      (key) => key.toLowerCase().includes(bossKey.toLowerCase())
+    );
+  };
+  const handleToggleKey = async (keyName, isActive) => {
+    if (isActive) {
+      const response = await rconManager.removeGlobalKey(keyName);
+      if (response) {
+        addLog("info", `Removed key: ${keyName}`);
+        const keys = await rconManager.listGlobalKeys();
+        setActiveKeys(keys);
+      } else {
+        addLog("error", `Failed to remove key: ${keyName}`);
+      }
+    } else {
+      const response = await rconManager.setGlobalKey(keyName);
+      if (response) {
+        addLog("info", `Set key: ${keyName}`);
+        const keys = await rconManager.listGlobalKeys();
+        setActiveKeys(keys);
+      } else {
+        addLog("error", `Failed to set key: ${keyName}`);
+      }
+    }
+  };
+  const handleResetAll = async () => {
+    const response = await rconManager.resetGlobalKeys();
+    if (response) {
+      addLog("warn", "Reset all global keys");
+      setActiveKeys([]);
+    } else {
+      addLog("error", "Failed to reset keys");
+    }
+  };
+  useInput4((input, key) => {
+    if (key.escape || input === "q" || input === "Q") {
+      onClose();
+      return;
+    }
+    if (key.upArrow) {
+      setSelectedIndex(Math.max(0, selectedIndex - 1));
+    } else if (key.downArrow) {
+      setSelectedIndex(Math.min(BOSS_KEYS.length - 1, selectedIndex + 1));
+    }
+    if (input === " " || key.return) {
+      const selected = BOSS_KEYS[selectedIndex];
+      const isActive = isBossDefeated(selected.key);
+      handleToggleKey(selected.key, isActive);
+    } else if (input === "r" || input === "R") {
+      handleResetAll();
+    }
+  });
+  if (!rconConnected) {
+    return /* @__PURE__ */ jsxs9(
+      Box10,
+      {
+        flexDirection: "column",
+        borderStyle: "round",
+        borderColor: theme.error,
+        padding: 1,
+        width: 60,
+        children: [
+          /* @__PURE__ */ jsx10(Box10, { marginBottom: 1, children: /* @__PURE__ */ jsx10(Text10, { bold: true, color: theme.error, children: "\u26A0 Global Keys Manager" }) }),
+          /* @__PURE__ */ jsx10(Text10, { dimColor: true, children: "RCON not connected" }),
+          /* @__PURE__ */ jsx10(Text10, { dimColor: true, children: "Key management requires RCON connection" }),
+          /* @__PURE__ */ jsx10(Box10, { marginTop: 1, children: /* @__PURE__ */ jsx10(Text10, { dimColor: true, children: "[Esc/Q] Close" }) })
+        ]
+      }
+    );
+  }
+  return /* @__PURE__ */ jsxs9(
+    Box10,
+    {
+      flexDirection: "column",
+      borderStyle: "round",
+      borderColor: theme.primary,
+      padding: 1,
+      width: 60,
+      children: [
+        /* @__PURE__ */ jsx10(Box10, { marginBottom: 1, children: /* @__PURE__ */ jsx10(Text10, { bold: true, color: theme.primary, children: "Boss Progression" }) }),
+        loading ? /* @__PURE__ */ jsx10(Text10, { dimColor: true, children: "Loading keys..." }) : /* @__PURE__ */ jsxs9(Fragment, { children: [
+          /* @__PURE__ */ jsx10(Box10, { marginBottom: 1, children: /* @__PURE__ */ jsx10(Text10, { dimColor: true, children: "Use \u2191\u2193 to select, [Space/Enter] to toggle" }) }),
+          /* @__PURE__ */ jsx10(Box10, { flexDirection: "column", children: BOSS_KEYS.map((boss, index) => {
+            const defeated = isBossDefeated(boss.key);
+            return /* @__PURE__ */ jsx10(Box10, { marginLeft: 1, children: /* @__PURE__ */ jsxs9(
+              Text10,
+              {
+                color: index === selectedIndex ? theme.primary : theme.secondary,
+                bold: index === selectedIndex,
+                children: [
+                  index === selectedIndex ? "\u2192 " : "  ",
+                  defeated ? "\u2611" : "\u2610",
+                  " ",
+                  boss.name
+                ]
+              }
+            ) }, boss.key);
+          }) }),
+          /* @__PURE__ */ jsx10(Box10, { marginTop: 2, flexDirection: "column", children: /* @__PURE__ */ jsx10(Text10, { color: theme.warning, children: "\u26A0\uFE0F Warning: Affects world progression" }) })
+        ] }),
+        /* @__PURE__ */ jsxs9(Box10, { marginTop: 1, flexDirection: "column", children: [
+          /* @__PURE__ */ jsx10(Text10, { dimColor: true, children: "[Space/Enter] Toggle [R] Reset All" }),
+          /* @__PURE__ */ jsx10(Text10, { dimColor: true, children: "[Esc/Q] Close" })
+        ] })
+      ]
+    }
+  );
+};
+
+// src/tui/components/Modal.tsx
+import { Box as Box11, Text as Text11, useInput as useInput5 } from "ink";
+import { jsx as jsx11, jsxs as jsxs10 } from "react/jsx-runtime";
 var Modal = (props) => {
   const { title, children, width = 50 } = props;
   const closeModal = useStore((s) => s.actions.closeModal);
-  useInput3((_input, key) => {
+  useInput5((_input, key) => {
     if (key.escape) {
       closeModal();
     }
   });
-  return /* @__PURE__ */ jsxs8(
-    Box9,
+  return /* @__PURE__ */ jsxs10(
+    Box11,
     {
       flexDirection: "column",
       width,
@@ -43010,36 +44326,36 @@ var Modal = (props) => {
       paddingX: 2,
       paddingY: 1,
       children: [
-        /* @__PURE__ */ jsxs8(Box9, { justifyContent: "space-between", marginBottom: 1, children: [
-          /* @__PURE__ */ jsx9(Text9, { bold: true, color: theme.primary, children: title }),
-          /* @__PURE__ */ jsx9(Text9, { dimColor: true, children: "[ESC to close]" })
+        /* @__PURE__ */ jsxs10(Box11, { justifyContent: "space-between", marginBottom: 1, children: [
+          /* @__PURE__ */ jsx11(Text11, { bold: true, color: theme.primary, children: title }),
+          /* @__PURE__ */ jsx11(Text11, { dimColor: true, children: "[ESC to close]" })
         ] }),
-        /* @__PURE__ */ jsx9(Box9, { flexDirection: "column", children })
+        /* @__PURE__ */ jsx11(Box11, { flexDirection: "column", children })
       ]
     }
   );
 };
 var ConfirmModal = (props) => {
   const { message, onConfirm, onCancel } = props;
-  useInput3((input, key) => {
+  useInput5((input, key) => {
     if (input === "y" || input === "Y") {
       onConfirm();
     } else if (input === "n" || input === "N" || key.escape) {
       onCancel();
     }
   });
-  return /* @__PURE__ */ jsxs8(Modal, { title: "Confirm", width: 40, children: [
-    /* @__PURE__ */ jsx9(Text9, { children: message }),
-    /* @__PURE__ */ jsxs8(Box9, { marginTop: 1, children: [
-      /* @__PURE__ */ jsx9(Text9, { color: theme.success, children: "[Y] Yes" }),
-      /* @__PURE__ */ jsx9(Text9, {}),
-      /* @__PURE__ */ jsx9(Text9, { color: theme.error, children: "[N] No" })
+  return /* @__PURE__ */ jsxs10(Modal, { title: "Confirm", width: 40, children: [
+    /* @__PURE__ */ jsx11(Text11, { children: message }),
+    /* @__PURE__ */ jsxs10(Box11, { marginTop: 1, children: [
+      /* @__PURE__ */ jsx11(Text11, { color: theme.success, children: "[Y] Yes" }),
+      /* @__PURE__ */ jsx11(Text11, {}),
+      /* @__PURE__ */ jsx11(Text11, { color: theme.error, children: "[N] No" })
     ] })
   ] });
 };
 var DeleteWorldModal = (props) => {
   const { worldName, backupCount, onConfirm, onCancel } = props;
-  useInput3((input, key) => {
+  useInput5((input, key) => {
     if (backupCount > 0) {
       if (input === "y" || input === "Y") {
         onConfirm(true);
@@ -43057,105 +44373,438 @@ var DeleteWorldModal = (props) => {
     }
   });
   if (backupCount > 0) {
-    return /* @__PURE__ */ jsxs8(Modal, { title: "Delete World", width: 50, children: [
-      /* @__PURE__ */ jsxs8(Text9, { children: [
+    return /* @__PURE__ */ jsxs10(Modal, { title: "Delete World", width: 50, children: [
+      /* @__PURE__ */ jsxs10(Text11, { children: [
         'Delete world "',
         worldName,
         '"?'
       ] }),
-      /* @__PURE__ */ jsx9(Box9, { marginTop: 1, children: /* @__PURE__ */ jsxs8(Text9, { dimColor: true, children: [
+      /* @__PURE__ */ jsx11(Box11, { marginTop: 1, children: /* @__PURE__ */ jsxs10(Text11, { dimColor: true, children: [
         "This world has ",
         backupCount,
         " backup",
         backupCount === 1 ? "" : "s",
         "."
       ] }) }),
-      /* @__PURE__ */ jsxs8(Box9, { marginTop: 1, flexDirection: "column", children: [
-        /* @__PURE__ */ jsx9(Text9, { color: theme.success, children: "[Y] Delete world and backups" }),
-        /* @__PURE__ */ jsx9(Text9, { color: theme.warning, children: "[N] Delete world only" }),
-        /* @__PURE__ */ jsx9(Text9, { color: theme.error, children: "[Esc] Cancel" })
+      /* @__PURE__ */ jsxs10(Box11, { marginTop: 1, flexDirection: "column", children: [
+        /* @__PURE__ */ jsx11(Text11, { color: theme.success, children: "[Y] Delete world and backups" }),
+        /* @__PURE__ */ jsx11(Text11, { color: theme.warning, children: "[N] Delete world only" }),
+        /* @__PURE__ */ jsx11(Text11, { color: theme.error, children: "[Esc] Cancel" })
       ] })
     ] });
   }
-  return /* @__PURE__ */ jsxs8(Modal, { title: "Confirm", width: 40, children: [
-    /* @__PURE__ */ jsxs8(Text9, { children: [
+  return /* @__PURE__ */ jsxs10(Modal, { title: "Confirm", width: 40, children: [
+    /* @__PURE__ */ jsxs10(Text11, { children: [
       'Delete world "',
       worldName,
       '"? This cannot be undone!'
     ] }),
-    /* @__PURE__ */ jsxs8(Box9, { marginTop: 1, children: [
-      /* @__PURE__ */ jsx9(Text9, { color: theme.success, children: "[Y] Yes" }),
-      /* @__PURE__ */ jsx9(Text9, {}),
-      /* @__PURE__ */ jsx9(Text9, { color: theme.error, children: "[N] No" })
+    /* @__PURE__ */ jsxs10(Box11, { marginTop: 1, children: [
+      /* @__PURE__ */ jsx11(Text11, { color: theme.success, children: "[Y] Yes" }),
+      /* @__PURE__ */ jsx11(Text11, {}),
+      /* @__PURE__ */ jsx11(Text11, { color: theme.error, children: "[N] No" })
     ] })
   ] });
 };
 
+// src/tui/components/PlayerManager.tsx
+init_mod();
+import { Box as Box12, Text as Text12, useInput as useInput6 } from "ink";
+import { useState as useState7 } from "react";
+import { Fragment as Fragment2, jsx as jsx12, jsxs as jsxs11 } from "react/jsx-runtime";
+var PlayerManager = ({ onClose }) => {
+  const players = useStore((s) => s.server.players);
+  const rconConnected = useStore((s) => s.rcon.connected);
+  const addLog = useStore((s) => s.actions.addLog);
+  const [selectedIndex, setSelectedIndex] = useState7(0);
+  const [view, setView] = useState7("players");
+  const [bannedPlayers, setBannedPlayers] = useState7([]);
+  const [loading, setLoading] = useState7(false);
+  const loadBannedPlayers = async () => {
+    setLoading(true);
+    const banned = await rconManager.getBannedPlayers();
+    setBannedPlayers(banned);
+    setLoading(false);
+  };
+  const handleKick = async (playerName) => {
+    const response = await rconManager.kickPlayer(playerName);
+    if (response) {
+      addLog("info", `Kicked ${playerName}: ${response}`);
+    } else {
+      addLog("error", `Failed to kick ${playerName}`);
+    }
+  };
+  const handleBan = async (playerName) => {
+    const response = await rconManager.banPlayer(playerName);
+    if (response) {
+      addLog("warn", `Banned ${playerName}: ${response}`);
+    } else {
+      addLog("error", `Failed to ban ${playerName}`);
+    }
+  };
+  const handleUnban = async (playerIdentifier) => {
+    const response = await rconManager.unbanPlayer(playerIdentifier);
+    if (response) {
+      addLog("info", `Unbanned ${playerIdentifier}: ${response}`);
+      await loadBannedPlayers();
+    } else {
+      addLog("error", `Failed to unban ${playerIdentifier}`);
+    }
+  };
+  useInput6((input, key) => {
+    if (key.escape || input === "q" || input === "Q") {
+      onClose();
+      return;
+    }
+    if (input === "t" || input === "T") {
+      if (view === "players") {
+        setView("banned");
+        loadBannedPlayers();
+      } else {
+        setView("players");
+      }
+      setSelectedIndex(0);
+      return;
+    }
+    const currentList = view === "players" ? players : bannedPlayers;
+    const maxIndex = Math.max(0, currentList.length - 1);
+    if (key.upArrow) {
+      setSelectedIndex(Math.max(0, selectedIndex - 1));
+    } else if (key.downArrow) {
+      setSelectedIndex(Math.min(maxIndex, selectedIndex + 1));
+    }
+    if (view === "players" && players.length > 0) {
+      const selectedPlayer = players[selectedIndex];
+      if (input === "k" || input === "K") {
+        handleKick(selectedPlayer);
+      } else if (input === "b" || input === "B") {
+        handleBan(selectedPlayer);
+      }
+    } else if (view === "banned" && bannedPlayers.length > 0) {
+      const selectedBanned = bannedPlayers[selectedIndex];
+      if (input === "u" || input === "U") {
+        handleUnban(selectedBanned);
+      }
+    }
+  });
+  if (!rconConnected) {
+    return /* @__PURE__ */ jsxs11(
+      Box12,
+      {
+        flexDirection: "column",
+        borderStyle: "round",
+        borderColor: theme.error,
+        padding: 1,
+        width: 60,
+        children: [
+          /* @__PURE__ */ jsx12(Box12, { marginBottom: 1, children: /* @__PURE__ */ jsx12(Text12, { bold: true, color: theme.error, children: "\u26A0 Player Management" }) }),
+          /* @__PURE__ */ jsx12(Text12, { dimColor: true, children: "RCON not connected" }),
+          /* @__PURE__ */ jsx12(Text12, { dimColor: true, children: "Player management requires RCON connection" }),
+          /* @__PURE__ */ jsx12(Box12, { marginTop: 1, children: /* @__PURE__ */ jsx12(Text12, { dimColor: true, children: "[Esc/Q] Close" }) })
+        ]
+      }
+    );
+  }
+  return /* @__PURE__ */ jsxs11(
+    Box12,
+    {
+      flexDirection: "column",
+      borderStyle: "round",
+      borderColor: theme.primary,
+      padding: 1,
+      width: 70,
+      children: [
+        /* @__PURE__ */ jsxs11(Box12, { marginBottom: 1, children: [
+          /* @__PURE__ */ jsx12(Text12, { bold: true, color: theme.primary, children: "Player Management" }),
+          /* @__PURE__ */ jsx12(Text12, { dimColor: true, children: " - " }),
+          /* @__PURE__ */ jsxs11(Text12, { color: view === "players" ? theme.success : theme.muted, children: [
+            "[T] ",
+            view === "players" ? "Online Players" : "Banned Players"
+          ] })
+        ] }),
+        view === "players" ? /* @__PURE__ */ jsx12(Box12, { flexDirection: "column", children: players.length === 0 ? /* @__PURE__ */ jsx12(Text12, { dimColor: true, children: "No players currently online" }) : /* @__PURE__ */ jsxs11(Fragment2, { children: [
+          /* @__PURE__ */ jsx12(Box12, { marginBottom: 1, children: /* @__PURE__ */ jsx12(Text12, { dimColor: true, children: "Use \u2191\u2193 to select, [K] Kick, [B] Ban" }) }),
+          players.map((player, index) => /* @__PURE__ */ jsx12(Box12, { marginLeft: 1, children: /* @__PURE__ */ jsxs11(
+            Text12,
+            {
+              color: index === selectedIndex ? theme.primary : theme.secondary,
+              bold: index === selectedIndex,
+              children: [
+                index === selectedIndex ? "\u2192 " : "  ",
+                player
+              ]
+            }
+          ) }, player))
+        ] }) }) : /* @__PURE__ */ jsx12(Box12, { flexDirection: "column", children: loading ? /* @__PURE__ */ jsx12(Text12, { dimColor: true, children: "Loading banned players..." }) : bannedPlayers.length === 0 ? /* @__PURE__ */ jsx12(Text12, { dimColor: true, children: "No banned players" }) : /* @__PURE__ */ jsxs11(Fragment2, { children: [
+          /* @__PURE__ */ jsx12(Box12, { marginBottom: 1, children: /* @__PURE__ */ jsx12(Text12, { dimColor: true, children: "Use \u2191\u2193 to select, [U] Unban" }) }),
+          bannedPlayers.map((banned, index) => /* @__PURE__ */ jsx12(Box12, { marginLeft: 1, children: /* @__PURE__ */ jsxs11(
+            Text12,
+            {
+              color: index === selectedIndex ? theme.warning : theme.secondary,
+              bold: index === selectedIndex,
+              children: [
+                index === selectedIndex ? "\u2192 " : "  ",
+                banned
+              ]
+            }
+          ) }, banned))
+        ] }) }),
+        /* @__PURE__ */ jsx12(Box12, { marginTop: 1, flexDirection: "column", children: /* @__PURE__ */ jsx12(Text12, { dimColor: true, children: "[Esc/Q] Close [T] Toggle View" }) })
+      ]
+    }
+  );
+};
+
+// src/tui/components/ServerInfoModal.tsx
+init_mod();
+import { Box as Box14, Text as Text14, useInput as useInput7 } from "ink";
+import { useEffect as useEffect7, useState as useState9 } from "react";
+
 // src/tui/components/Spinner.tsx
-import { Box as Box10, Text as Text10 } from "ink";
-import { useEffect as useEffect5, useState as useState5 } from "react";
-import { jsx as jsx10, jsxs as jsxs9 } from "react/jsx-runtime";
+import { Box as Box13, Text as Text13 } from "ink";
+import { useEffect as useEffect6, useState as useState8 } from "react";
+import { jsx as jsx13, jsxs as jsxs12 } from "react/jsx-runtime";
 var SPINNER_FRAMES = ["\u280B", "\u2819", "\u2839", "\u2838", "\u283C", "\u2834", "\u2826", "\u2827", "\u2807", "\u280F"];
 var SPINNER_INTERVAL = 80;
 var Spinner = (props) => {
   const { label, color = valheimPalette.mandarin } = props;
-  const [frame, setFrame] = useState5(0);
-  useEffect5(() => {
+  const [frame, setFrame] = useState8(0);
+  useEffect6(() => {
     const timer = setInterval(() => {
       setFrame((f) => (f + 1) % SPINNER_FRAMES.length);
     }, SPINNER_INTERVAL);
     return () => clearInterval(timer);
   }, []);
-  return /* @__PURE__ */ jsxs9(Box10, { children: [
-    /* @__PURE__ */ jsx10(Text10, { color, children: SPINNER_FRAMES[frame] }),
-    label && /* @__PURE__ */ jsxs9(Text10, { children: [
+  return /* @__PURE__ */ jsxs12(Box13, { children: [
+    /* @__PURE__ */ jsx13(Text13, { color, children: SPINNER_FRAMES[frame] }),
+    label && /* @__PURE__ */ jsxs12(Text13, { children: [
       " ",
       label
     ] })
   ] });
 };
 
+// src/tui/components/ServerInfoModal.tsx
+import { Fragment as Fragment3, jsx as jsx14, jsxs as jsxs13 } from "react/jsx-runtime";
+var ServerInfoModal = ({ onClose }) => {
+  const [info2, setInfo] = useState9("");
+  const [ping, setPing] = useState9("");
+  const [loading, setLoading] = useState9(true);
+  useEffect7(() => {
+    const fetchInfo = async () => {
+      setLoading(true);
+      const [infoResponse, pingResponse] = await Promise.all([
+        rconManager.getServerInfo(),
+        rconManager.pingServer()
+      ]);
+      setInfo(infoResponse || "No info available");
+      setPing(pingResponse || "");
+      setLoading(false);
+    };
+    fetchInfo();
+  }, []);
+  useInput7((input, key) => {
+    if (key.escape || input === "q" || input === "Q") {
+      onClose();
+    }
+  });
+  return /* @__PURE__ */ jsxs13(
+    Box14,
+    {
+      flexDirection: "column",
+      borderStyle: "round",
+      borderColor: theme.primary,
+      padding: 1,
+      width: 70,
+      children: [
+        /* @__PURE__ */ jsx14(Box14, { marginBottom: 1, children: /* @__PURE__ */ jsx14(Text14, { bold: true, color: theme.primary, children: "Server Information" }) }),
+        loading ? /* @__PURE__ */ jsx14(Box14, { marginY: 2, children: /* @__PURE__ */ jsx14(Spinner, { label: "Fetching server info..." }) }) : /* @__PURE__ */ jsxs13(Box14, { flexDirection: "column", children: [
+          /* @__PURE__ */ jsx14(Box14, { marginBottom: 1, children: /* @__PURE__ */ jsx14(Text14, { bold: true, children: "Info:" }) }),
+          /* @__PURE__ */ jsx14(Box14, { marginLeft: 2, marginBottom: 1, children: /* @__PURE__ */ jsx14(Text14, { children: info2 }) }),
+          ping && /* @__PURE__ */ jsxs13(Fragment3, { children: [
+            /* @__PURE__ */ jsx14(Box14, { marginBottom: 1, children: /* @__PURE__ */ jsx14(Text14, { bold: true, children: "Ping:" }) }),
+            /* @__PURE__ */ jsx14(Box14, { marginLeft: 2, marginBottom: 1, children: /* @__PURE__ */ jsx14(Text14, { color: theme.success, children: ping }) })
+          ] })
+        ] }),
+        /* @__PURE__ */ jsx14(Box14, { marginTop: 1, children: /* @__PURE__ */ jsx14(Text14, { dimColor: true, children: "[Esc/Q] Close" }) })
+      ]
+    }
+  );
+};
+
+// src/tui/components/TimeControl.tsx
+init_mod();
+import { Box as Box15, Text as Text15, useInput as useInput8 } from "ink";
+import { useState as useState10 } from "react";
+import { jsx as jsx15, jsxs as jsxs14 } from "react/jsx-runtime";
+var TIME_OPTIONS = [
+  { index: 0, label: "Sleep (Skip to morning)", seconds: 0 },
+  { index: 1, label: "Skip 1 hour", seconds: 3600 },
+  { index: 2, label: "Skip 3 hours", seconds: 10800 },
+  { index: 3, label: "Skip 6 hours", seconds: 21600 },
+  { index: 4, label: "Skip 12 hours", seconds: 43200 },
+  { index: 5, label: "Skip 1 day", seconds: 86400 }
+];
+var TimeControl = ({ onClose }) => {
+  const rconConnected = useStore((s) => s.rcon.connected);
+  const addLog = useStore((s) => s.actions.addLog);
+  const [selectedIndex, setSelectedIndex] = useState10(0);
+  const handleTimeSkip = async (seconds, label) => {
+    if (seconds === 0) {
+      const response = await rconManager.sleep();
+      if (response) {
+        addLog("info", `Sleeping through night: ${response}`);
+      } else {
+        addLog("error", "Failed to sleep");
+      }
+    } else {
+      const response = await rconManager.skipTime(seconds);
+      if (response) {
+        addLog("info", `${label}: ${response}`);
+      } else {
+        addLog("error", `Failed to skip time: ${label}`);
+      }
+    }
+  };
+  useInput8((input, key) => {
+    if (key.escape || input === "q" || input === "Q") {
+      onClose();
+      return;
+    }
+    if (key.upArrow) {
+      setSelectedIndex(Math.max(0, selectedIndex - 1));
+    } else if (key.downArrow) {
+      setSelectedIndex(Math.min(TIME_OPTIONS.length - 1, selectedIndex + 1));
+    }
+    if (key.return) {
+      const selected = TIME_OPTIONS[selectedIndex];
+      handleTimeSkip(selected.seconds, selected.label);
+    }
+  });
+  if (!rconConnected) {
+    return /* @__PURE__ */ jsxs14(
+      Box15,
+      {
+        flexDirection: "column",
+        borderStyle: "round",
+        borderColor: theme.error,
+        padding: 1,
+        width: 60,
+        children: [
+          /* @__PURE__ */ jsx15(Box15, { marginBottom: 1, children: /* @__PURE__ */ jsx15(Text15, { bold: true, color: theme.error, children: "\u26A0 Time Control" }) }),
+          /* @__PURE__ */ jsx15(Text15, { dimColor: true, children: "RCON not connected" }),
+          /* @__PURE__ */ jsx15(Text15, { dimColor: true, children: "Time control requires RCON connection" }),
+          /* @__PURE__ */ jsx15(Box15, { marginTop: 1, children: /* @__PURE__ */ jsx15(Text15, { dimColor: true, children: "[Esc/Q] Close" }) })
+        ]
+      }
+    );
+  }
+  return /* @__PURE__ */ jsxs14(
+    Box15,
+    {
+      flexDirection: "column",
+      borderStyle: "round",
+      borderColor: theme.primary,
+      padding: 1,
+      width: 50,
+      children: [
+        /* @__PURE__ */ jsx15(Box15, { marginBottom: 1, children: /* @__PURE__ */ jsx15(Text15, { bold: true, color: theme.primary, children: "Time Control" }) }),
+        /* @__PURE__ */ jsx15(Box15, { marginBottom: 1, children: /* @__PURE__ */ jsx15(Text15, { dimColor: true, children: "Use \u2191\u2193 to select, [Enter] to execute" }) }),
+        /* @__PURE__ */ jsx15(Box15, { flexDirection: "column", children: TIME_OPTIONS.map((option) => /* @__PURE__ */ jsx15(Box15, { marginLeft: 1, children: /* @__PURE__ */ jsxs14(
+          Text15,
+          {
+            color: option.index === selectedIndex ? theme.primary : theme.secondary,
+            bold: option.index === selectedIndex,
+            children: [
+              option.index === selectedIndex ? "\u2192 " : "  ",
+              option.label
+            ]
+          }
+        ) }, option.index)) }),
+        /* @__PURE__ */ jsx15(Box15, { marginTop: 2, children: /* @__PURE__ */ jsx15(Text15, { dimColor: true, children: "\u26A0\uFE0F Warning: Time skip affects all players" }) }),
+        /* @__PURE__ */ jsx15(Box15, { marginTop: 1, flexDirection: "column", children: /* @__PURE__ */ jsx15(Text15, { dimColor: true, children: "[Enter] Execute [Esc/Q] Close" }) })
+      ]
+    }
+  );
+};
+
 // src/tui/hooks/useServer.ts
-import { useCallback as useCallback3, useEffect as useEffect6 } from "react";
+init_mod();
+import { useCallback as useCallback3, useEffect as useEffect8, useRef as useRef3 } from "react";
 
 // src/tui/serverManager.ts
 var watchdog = null;
 var updating = false;
+var isAttached = false;
 function getWatchdog() {
   return watchdog;
 }
 function hasActiveServer() {
   return watchdog !== null;
 }
+function isAttachedToServer() {
+  return isAttached;
+}
 function isUpdating() {
   return updating;
 }
 function setUpdating(value) {
   updating = value;
 }
+async function checkRunningServer() {
+  return getRunningServer();
+}
+async function attachToServer(pidData, events) {
+  if (watchdog) {
+    throw new Error("Already managing a server - stop it first");
+  }
+  const config = {
+    name: pidData.serverName ?? "Valheim Server",
+    port: pidData.port,
+    world: pidData.world,
+    password: "",
+    // Not needed for attach
+    public: false,
+    crossplay: false,
+    detached: true
+  };
+  watchdog = new Watchdog(config, { enabled: false }, events);
+  await watchdog.serverProcess.attach(pidData);
+  isAttached = true;
+  return watchdog;
+}
 async function startServer(config, watchdogConfig, events) {
   if (watchdog) {
     throw new Error("Server is already running");
   }
-  watchdog = new Watchdog(config, watchdogConfig, events);
-  await watchdog.start();
-  const pid = watchdog.serverProcess.pid;
-  if (pid) {
-    await writePidFile({
-      pid,
-      startedAt: (/* @__PURE__ */ new Date()).toISOString(),
-      world: config.world,
-      port: config.port
-    });
+  const running = await getRunningServer();
+  if (running) {
+    throw new Error(
+      `A server is already running (PID: ${running.pid}, World: ${running.world}). Stop it first or attach to it.`
+    );
   }
+  const detachedConfig = {
+    ...config,
+    detached: true
+  };
+  watchdog = new Watchdog(detachedConfig, watchdogConfig, events);
+  await watchdog.start();
+  isAttached = false;
   return watchdog;
 }
-async function stopServer() {
+async function stopServer(keepRunning = false) {
   if (!watchdog) {
     return;
   }
+  if (keepRunning && isAttached) {
+    await watchdog.serverProcess.detach();
+    watchdog = null;
+    isAttached = false;
+    return;
+  }
   await watchdog.stop();
   watchdog = null;
+  isAttached = false;
   await removePidFile();
 }
 async function killServer() {
@@ -43164,21 +44813,46 @@ async function killServer() {
   }
   await watchdog.kill();
   watchdog = null;
+  isAttached = false;
   await removePidFile();
 }
+async function detachFromServer() {
+  if (!watchdog) {
+    return;
+  }
+  if (!isAttached && !watchdog.serverProcess.isDetached) {
+    throw new Error("Cannot detach from a non-detached server");
+  }
+  await watchdog.serverProcess.detach();
+  watchdog = null;
+  isAttached = false;
+}
+function getLogFilePath() {
+  return watchdog?.serverProcess.logFilePath ?? null;
+}
 async function cleanupOnExit() {
-  if (watchdog) {
+  if (!watchdog) {
+    return;
+  }
+  if (isAttached || watchdog.serverProcess.isDetached) {
     try {
-      await watchdog.stop();
+      await watchdog.serverProcess.detach();
     } catch {
-      try {
-        await watchdog.kill();
-      } catch {
-      }
     }
     watchdog = null;
-    await removePidFile();
+    isAttached = false;
+    return;
+  }
+  try {
+    await watchdog.stop();
+  } catch {
+    try {
+      await watchdog.kill();
+    } catch {
+    }
   }
+  watchdog = null;
+  await removePidFile();
 }
 
 // src/tui/hooks/useServer.ts
@@ -43214,6 +44888,7 @@ function useServer() {
   const config = useStore((s) => s.config);
   const rcon = useStore((s) => s.rcon);
   const actions = useStore((s) => s.actions);
+  const hasCheckedForRunning = useRef3(false);
   const createWatchdogEvents = useCallback3(
     () => ({
       onStateChange: (state) => {
@@ -43285,6 +44960,38 @@ function useServer() {
     }),
     [actions]
   );
+  const checkAndAttach = useCallback3(async () => {
+    if (hasActiveServer()) {
+      return;
+    }
+    const running = await checkRunningServer();
+    if (!running) {
+      return;
+    }
+    actions.addLog(
+      "info",
+      `Found running server (PID: ${running.pid}, World: ${running.world})`
+    );
+    actions.addLog("info", "Attaching to running server...");
+    try {
+      const events = createWatchdogEvents();
+      await attachToServer(running, events);
+      actions.setServerPid(running.pid);
+      actions.setWorld(running.world);
+      actions.setServerStatus("online");
+      actions.setStartupPhase("ready");
+      actions.addLog("info", "Successfully attached to running server");
+    } catch (error2) {
+      actions.addLog("error", `Failed to attach to running server: ${error2}`);
+    }
+  }, [actions, createWatchdogEvents]);
+  useEffect8(() => {
+    if (hasCheckedForRunning.current) return;
+    hasCheckedForRunning.current = true;
+    checkAndAttach().catch((error2) => {
+      actions.addLog("error", `Error checking for running server: ${error2}`);
+    });
+  }, [checkAndAttach, actions]);
   const start = useCallback3(async () => {
     if (status !== "offline") {
       actions.addLog("warn", "Server is not offline, cannot start");
@@ -43405,13 +45112,78 @@ function useServer() {
       actions.addLog("error", `Failed to send save command: ${error2}`);
     }
   }, [rcon, actions]);
-  useEffect6(() => {
+  const detach = useCallback3(async () => {
+    if (!hasActiveServer()) {
+      actions.addLog("warn", "No server to detach from");
+      return;
+    }
+    try {
+      await detachFromServer();
+      actions.addLog("info", "Detached from server - it will continue running");
+    } catch (error2) {
+      actions.addLog("error", `Failed to detach: ${error2}`);
+    }
+  }, [actions]);
+  useEffect8(() => {
     if (status !== "online") return;
     const interval = setInterval(() => {
       actions.incrementUptime();
     }, 1e3);
     return () => clearInterval(interval);
   }, [status, actions]);
+  useEffect8(() => {
+    if (!rcon.enabled) {
+      if (rconManager.isConnected()) {
+        rconManager.disconnect();
+        actions.setRconConnected(false);
+      }
+      return;
+    }
+    rconManager.initialize(
+      {
+        host: "localhost",
+        port: rcon.port,
+        password: rcon.password,
+        timeout: rcon.timeout,
+        enabled: rcon.enabled,
+        autoReconnect: rcon.autoReconnect
+      },
+      {
+        onConnectionStateChange: (state) => {
+          const connected = state === "connected";
+          actions.setRconConnected(connected);
+          if (connected) {
+            actions.addLog("info", "RCON connected");
+          } else if (state === "error") {
+            actions.addLog("warn", "RCON connection error");
+          } else if (state === "disconnected") {
+            actions.addLog("info", "RCON disconnected");
+          }
+        },
+        onPlayerListUpdate: (players) => {
+          actions.setPlayers(players);
+        },
+        pollInterval: 1e4
+        // Poll every 10 seconds
+      }
+    );
+    return () => {
+      rconManager.disconnect();
+    };
+  }, [rcon, actions]);
+  useEffect8(() => {
+    if (status === "online" && rcon.enabled && !rconManager.isConnected()) {
+      const timer = setTimeout(() => {
+        rconManager.connect().catch((error2) => {
+          actions.addLog("warn", `RCON connection failed: ${error2}`);
+        });
+      }, 3e3);
+      return () => clearTimeout(timer);
+    }
+    if (status === "offline" && rconManager.isConnected()) {
+      rconManager.disconnect();
+    }
+  }, [status, rcon.enabled, actions]);
   return {
     status,
     start,
@@ -43420,16 +45192,20 @@ function useServer() {
     restart,
     update,
     forceSave,
+    detach,
+    checkAndAttach,
     isOnline: status === "online",
     isOffline: status === "offline",
     isTransitioning: status === "starting" || status === "stopping",
     isUpdating: isUpdating(),
+    isAttached: isAttachedToServer(),
+    logFilePath: getLogFilePath(),
     watchdog: getWatchdog()
   };
 }
 
 // src/tui/screens/Dashboard.tsx
-import { jsx as jsx11, jsxs as jsxs10 } from "react/jsx-runtime";
+import { Fragment as Fragment4, jsx as jsx16, jsxs as jsxs15 } from "react/jsx-runtime";
 function formatUptime2(seconds) {
   if (seconds === 0) return "N/A";
   const hours = Math.floor(seconds / 3600);
@@ -43491,6 +45267,8 @@ var Dashboard = () => {
   const memoryUsage = useStore((s) => s.server.memoryUsage);
   const startupPhase = useStore((s) => s.server.startupPhase);
   const config = useStore((s) => s.config);
+  const rconConfig = useStore((s) => s.rcon);
+  const rconConnected = useStore((s) => s.rcon.connected);
   const modalOpen = useStore((s) => s.ui.modalOpen);
   const openModal = useStore((s) => s.actions.openModal);
   const closeModal = useStore((s) => s.actions.closeModal);
@@ -43526,12 +45304,12 @@ var Dashboard = () => {
   const setValheimBuildId = useStore((s) => s.actions.setValheimBuildId);
   const resetValheimInstall = useStore((s) => s.actions.resetValheimInstall);
   const { start, stop, restart, update, forceSave } = useServer();
-  const [isUpdating2, setIsUpdating] = useState6(false);
-  const [updateProgress, setUpdateProgress] = useState6("");
-  const [startupTaskRegistered, setStartupTaskRegistered] = useState6(null);
-  const [startupTaskProcessing, setStartupTaskProcessing] = useState6(false);
+  const [isUpdating2, setIsUpdating] = useState11(false);
+  const [updateProgress, setUpdateProgress] = useState11("");
+  const [startupTaskRegistered, setStartupTaskRegistered] = useState11(null);
+  const [startupTaskProcessing, setStartupTaskProcessing] = useState11(false);
   const statusColor = getStatusColor(status);
-  useEffect7(() => {
+  useEffect9(() => {
     const checkSteamCmd2 = async () => {
       try {
         const installed = await isSteamCmdInstalled();
@@ -43546,7 +45324,7 @@ var Dashboard = () => {
     };
     checkSteamCmd2();
   }, [setSteamCmdInstalled, setSteamCmdPath]);
-  useEffect7(() => {
+  useEffect9(() => {
     if (steamCmdInstalled !== true) return;
     const checkValheim = async () => {
       try {
@@ -43577,7 +45355,7 @@ var Dashboard = () => {
     setValheimBuildId,
     addLog
   ]);
-  useEffect7(() => {
+  useEffect9(() => {
     if (steamCmdInstalled === true && valheimInstalled === false && !valheimInstalling) {
       const autoInstallValheim = async () => {
         setValheimInstalling(true);
@@ -43636,7 +45414,7 @@ var Dashboard = () => {
     resetValheimInstall,
     addLog
   ]);
-  useEffect7(() => {
+  useEffect9(() => {
     const checkStartupTask = async () => {
       try {
         const registered = await isStartupTaskRegistered();
@@ -43778,7 +45556,7 @@ var Dashboard = () => {
       setStartupTaskProcessing(false);
     }
   };
-  useInput4((input) => {
+  useInput9((input) => {
     if (modalOpen || isUpdating2 || steamCmdInstalling || valheimInstalling || startupTaskProcessing)
       return;
     if (input === "s" || input === "S") {
@@ -43790,7 +45568,7 @@ var Dashboard = () => {
     if (input === "x" || input === "X") {
       if (status === "online") {
         openModal(
-          /* @__PURE__ */ jsx11(
+          /* @__PURE__ */ jsx16(
             ConfirmModal,
             {
               message: "Stop the server? Players will be disconnected.",
@@ -43804,7 +45582,7 @@ var Dashboard = () => {
     if (input === "r" || input === "R") {
       if (status === "online") {
         openModal(
-          /* @__PURE__ */ jsx11(
+          /* @__PURE__ */ jsx16(
             ConfirmModal,
             {
               message: "Restart the server? Players will be briefly disconnected.",
@@ -43818,7 +45596,7 @@ var Dashboard = () => {
     if (input === "u" || input === "U") {
       if (status === "offline" && steamCmdInstalled && valheimInstalled) {
         openModal(
-          /* @__PURE__ */ jsx11(
+          /* @__PURE__ */ jsx16(
             ConfirmModal,
             {
               message: "Update server via SteamCMD? This may take a few minutes.",
@@ -43832,7 +45610,7 @@ var Dashboard = () => {
     if (input === "i" || input === "I") {
       if (!steamCmdInstalled && !steamCmdInstalling) {
         openModal(
-          /* @__PURE__ */ jsx11(
+          /* @__PURE__ */ jsx16(
             ConfirmModal,
             {
               message: "Install SteamCMD? This is required to download and update Valheim.",
@@ -43847,7 +45625,7 @@ var Dashboard = () => {
       if (steamCmdInstalled && !valheimInstalling) {
         const action = valheimInstalled === false ? "Install" : "Reinstall/Verify";
         openModal(
-          /* @__PURE__ */ jsx11(
+          /* @__PURE__ */ jsx16(
             ConfirmModal,
             {
               message: `${action} Valheim Dedicated Server? This may take several minutes.`,
@@ -43866,7 +45644,7 @@ var Dashboard = () => {
     if (input === "k" || input === "K") {
       if (status === "online" || status === "starting" || status === "stopping") {
         openModal(
-          /* @__PURE__ */ jsx11(
+          /* @__PURE__ */ jsx16(
             ConfirmModal,
             {
               message: "Force kill the server? Data may be lost!",
@@ -43881,7 +45659,7 @@ var Dashboard = () => {
       if (startupTaskRegistered === null) return;
       const action = startupTaskRegistered ? "Remove" : "Enable";
       openModal(
-        /* @__PURE__ */ jsx11(
+        /* @__PURE__ */ jsx16(
           ConfirmModal,
           {
             message: `${action} auto-start at login? The server manager will ${startupTaskRegistered ? "no longer" : ""} start automatically when you log in.`,
@@ -43891,256 +45669,336 @@ var Dashboard = () => {
         )
       );
     }
+    if (rconConnected && status === "online") {
+      if (input === "p" || input === "P") {
+        openModal(/* @__PURE__ */ jsx16(PlayerManager, { onClose: closeModal }));
+      }
+      if (input === "n" || input === "N") {
+        openModal(/* @__PURE__ */ jsx16(ServerInfoModal, { onClose: closeModal }));
+      }
+      if (input === "e" || input === "E") {
+        openModal(/* @__PURE__ */ jsx16(EventManager, { onClose: closeModal }));
+      }
+      if (input === "t" || input === "T") {
+        openModal(/* @__PURE__ */ jsx16(TimeControl, { onClose: closeModal }));
+      }
+      if (input === "g" || input === "G") {
+        openModal(/* @__PURE__ */ jsx16(GlobalKeysManager, { onClose: closeModal }));
+      }
+      if (input === "d" || input === "D") {
+        openModal(
+          /* @__PURE__ */ jsx16(
+            ConfirmModal,
+            {
+              message: "Remove all dropped items from the world? This cannot be undone.",
+              onConfirm: async () => {
+                closeModal();
+                const { rconManager: rconManager2 } = await Promise.resolve().then(() => (init_mod(), mod_exports));
+                const response = await rconManager2.removeDrops();
+                addLog("info", `Remove drops: ${response || "Done"}`);
+              },
+              onCancel: closeModal
+            }
+          )
+        );
+      }
+    }
   });
   const renderStatusWithLoading = () => {
     if (status === "starting") {
       const phaseDesc = getPhaseDescription(startupPhase);
-      return /* @__PURE__ */ jsxs10(Box11, { flexDirection: "column", children: [
-        /* @__PURE__ */ jsxs10(Box11, { children: [
-          /* @__PURE__ */ jsx11(Spinner, {}),
-          /* @__PURE__ */ jsxs10(Text11, { color: statusColor, bold: true, children: [
+      return /* @__PURE__ */ jsxs15(Box16, { flexDirection: "column", children: [
+        /* @__PURE__ */ jsxs15(Box16, { children: [
+          /* @__PURE__ */ jsx16(Spinner, {}),
+          /* @__PURE__ */ jsxs15(Text16, { color: statusColor, bold: true, children: [
             " ",
             "STARTING"
           ] })
         ] }),
-        phaseDesc && /* @__PURE__ */ jsx11(Box11, { marginLeft: 2, children: /* @__PURE__ */ jsx11(Text11, { dimColor: true, children: phaseDesc }) })
+        phaseDesc && /* @__PURE__ */ jsx16(Box16, { marginLeft: 2, children: /* @__PURE__ */ jsx16(Text16, { dimColor: true, children: phaseDesc }) })
       ] });
     }
     if (status === "stopping") {
-      return /* @__PURE__ */ jsxs10(Box11, { children: [
-        /* @__PURE__ */ jsx11(Spinner, {}),
-        /* @__PURE__ */ jsxs10(Text11, { color: statusColor, bold: true, children: [
+      return /* @__PURE__ */ jsxs15(Box16, { children: [
+        /* @__PURE__ */ jsx16(Spinner, {}),
+        /* @__PURE__ */ jsxs15(Text16, { color: statusColor, bold: true, children: [
           " ",
           "STOPPING"
         ] })
       ] });
     }
     if (status === "online" && startupPhase === "ready") {
-      return /* @__PURE__ */ jsx11(Text11, { color: statusColor, bold: true, children: "\u25CF ONLINE (Ready to join)" });
+      return /* @__PURE__ */ jsx16(Text16, { color: statusColor, bold: true, children: "\u25CF ONLINE (Ready to join)" });
     }
-    return /* @__PURE__ */ jsxs10(Text11, { color: statusColor, bold: true, children: [
+    return /* @__PURE__ */ jsxs15(Text16, { color: statusColor, bold: true, children: [
       "\u25CF ",
       status.toUpperCase()
     ] });
   };
   if (isUpdating2) {
-    return /* @__PURE__ */ jsxs10(Box11, { flexDirection: "column", flexGrow: 1, padding: 1, children: [
-      /* @__PURE__ */ jsx11(Box11, { marginBottom: 1, children: /* @__PURE__ */ jsx11(Text11, { bold: true, color: theme.primary, children: "\u2500 Dashboard \u2500" }) }),
-      /* @__PURE__ */ jsxs10(
-        Box11,
+    return /* @__PURE__ */ jsxs15(Box16, { flexDirection: "column", flexGrow: 1, padding: 1, children: [
+      /* @__PURE__ */ jsx16(Box16, { marginBottom: 1, children: /* @__PURE__ */ jsx16(Text16, { bold: true, color: theme.primary, children: "\u2500 Dashboard \u2500" }) }),
+      /* @__PURE__ */ jsxs15(
+        Box16,
         {
           flexDirection: "column",
           alignItems: "center",
           justifyContent: "center",
           flexGrow: 1,
           children: [
-            /* @__PURE__ */ jsx11(Spinner, { label: "Updating server..." }),
-            updateProgress && /* @__PURE__ */ jsx11(Box11, { marginTop: 1, children: /* @__PURE__ */ jsx11(Text11, { dimColor: true, children: updateProgress }) }),
-            /* @__PURE__ */ jsx11(Box11, { marginTop: 1, children: /* @__PURE__ */ jsx11(Text11, { dimColor: true, children: "Please wait, this may take several minutes..." }) })
+            /* @__PURE__ */ jsx16(Spinner, { label: "Updating server..." }),
+            updateProgress && /* @__PURE__ */ jsx16(Box16, { marginTop: 1, children: /* @__PURE__ */ jsx16(Text16, { dimColor: true, children: updateProgress }) }),
+            /* @__PURE__ */ jsx16(Box16, { marginTop: 1, children: /* @__PURE__ */ jsx16(Text16, { dimColor: true, children: "Please wait, this may take several minutes..." }) })
           ]
         }
       )
     ] });
   }
   if (steamCmdInstalling) {
-    return /* @__PURE__ */ jsxs10(Box11, { flexDirection: "column", flexGrow: 1, padding: 1, children: [
-      /* @__PURE__ */ jsx11(Box11, { marginBottom: 1, children: /* @__PURE__ */ jsx11(Text11, { bold: true, color: theme.primary, children: "\u2500 Dashboard \u2500" }) }),
-      /* @__PURE__ */ jsxs10(
-        Box11,
+    return /* @__PURE__ */ jsxs15(Box16, { flexDirection: "column", flexGrow: 1, padding: 1, children: [
+      /* @__PURE__ */ jsx16(Box16, { marginBottom: 1, children: /* @__PURE__ */ jsx16(Text16, { bold: true, color: theme.primary, children: "\u2500 Dashboard \u2500" }) }),
+      /* @__PURE__ */ jsxs15(
+        Box16,
         {
           flexDirection: "column",
           alignItems: "center",
           justifyContent: "center",
           flexGrow: 1,
           children: [
-            /* @__PURE__ */ jsx11(Spinner, { label: "Installing SteamCMD..." }),
-            steamCmdProgress && /* @__PURE__ */ jsx11(Box11, { marginTop: 1, children: /* @__PURE__ */ jsxs10(Text11, { dimColor: true, children: [
+            /* @__PURE__ */ jsx16(Spinner, { label: "Installing SteamCMD..." }),
+            steamCmdProgress && /* @__PURE__ */ jsx16(Box16, { marginTop: 1, children: /* @__PURE__ */ jsxs15(Text16, { dimColor: true, children: [
               steamCmdProgress,
               steamCmdPercent > 0 && ` (${steamCmdPercent}%)`
             ] }) }),
-            /* @__PURE__ */ jsx11(Box11, { marginTop: 1, children: /* @__PURE__ */ jsx11(Text11, { dimColor: true, children: "Please wait..." }) })
+            /* @__PURE__ */ jsx16(Box16, { marginTop: 1, children: /* @__PURE__ */ jsx16(Text16, { dimColor: true, children: "Please wait..." }) })
           ]
         }
       )
     ] });
   }
   if (valheimInstalling) {
-    return /* @__PURE__ */ jsxs10(Box11, { flexDirection: "column", flexGrow: 1, padding: 1, children: [
-      /* @__PURE__ */ jsx11(Box11, { marginBottom: 1, children: /* @__PURE__ */ jsx11(Text11, { bold: true, color: theme.primary, children: "\u2500 Dashboard \u2500" }) }),
-      /* @__PURE__ */ jsxs10(
-        Box11,
+    return /* @__PURE__ */ jsxs15(Box16, { flexDirection: "column", flexGrow: 1, padding: 1, children: [
+      /* @__PURE__ */ jsx16(Box16, { marginBottom: 1, children: /* @__PURE__ */ jsx16(Text16, { bold: true, color: theme.primary, children: "\u2500 Dashboard \u2500" }) }),
+      /* @__PURE__ */ jsxs15(
+        Box16,
         {
           flexDirection: "column",
           alignItems: "center",
           justifyContent: "center",
           flexGrow: 1,
           children: [
-            /* @__PURE__ */ jsx11(Spinner, { label: "Installing Valheim Dedicated Server..." }),
-            valheimProgress && /* @__PURE__ */ jsx11(Box11, { marginTop: 1, children: /* @__PURE__ */ jsxs10(Text11, { dimColor: true, children: [
+            /* @__PURE__ */ jsx16(Spinner, { label: "Installing Valheim Dedicated Server..." }),
+            valheimProgress && /* @__PURE__ */ jsx16(Box16, { marginTop: 1, children: /* @__PURE__ */ jsxs15(Text16, { dimColor: true, children: [
               valheimProgress,
               valheimPercent > 0 && ` (${valheimPercent}%)`
             ] }) }),
-            /* @__PURE__ */ jsx11(Box11, { marginTop: 1, children: /* @__PURE__ */ jsx11(Text11, { dimColor: true, children: "Please wait, this may take several minutes..." }) })
+            /* @__PURE__ */ jsx16(Box16, { marginTop: 1, children: /* @__PURE__ */ jsx16(Text16, { dimColor: true, children: "Please wait, this may take several minutes..." }) })
           ]
         }
       )
     ] });
   }
-  return /* @__PURE__ */ jsxs10(Box11, { flexDirection: "column", flexGrow: 1, padding: 1, children: [
-    /* @__PURE__ */ jsx11(Box11, { marginBottom: 1, children: /* @__PURE__ */ jsx11(Text11, { bold: true, color: theme.primary, children: "\u2500 Dashboard \u2500" }) }),
-    /* @__PURE__ */ jsxs10(Box11, { flexDirection: "column", marginBottom: 1, children: [
-      /* @__PURE__ */ jsx11(Text11, { bold: true, children: "SteamCMD" }),
-      /* @__PURE__ */ jsxs10(Box11, { marginLeft: 2, flexDirection: "column", children: [
-        /* @__PURE__ */ jsxs10(Box11, { flexShrink: 0, children: [
-          /* @__PURE__ */ jsx11(Text11, { children: "Status: " }),
-          steamCmdInstalled === null ? /* @__PURE__ */ jsx11(Text11, { dimColor: true, children: "Checking..." }) : steamCmdInstalled ? /* @__PURE__ */ jsx11(Text11, { color: theme.success, children: "\u25CF Installed" }) : /* @__PURE__ */ jsx11(Text11, { color: theme.warning, children: "\u25CB Not Installed" })
+  return /* @__PURE__ */ jsxs15(Box16, { flexDirection: "column", flexGrow: 1, padding: 1, children: [
+    /* @__PURE__ */ jsx16(Box16, { marginBottom: 1, children: /* @__PURE__ */ jsx16(Text16, { bold: true, color: theme.primary, children: "\u2500 Dashboard \u2500" }) }),
+    /* @__PURE__ */ jsxs15(Box16, { flexDirection: "column", marginBottom: 1, children: [
+      /* @__PURE__ */ jsx16(Text16, { bold: true, children: "SteamCMD" }),
+      /* @__PURE__ */ jsxs15(Box16, { marginLeft: 2, flexDirection: "column", children: [
+        /* @__PURE__ */ jsxs15(Box16, { flexShrink: 0, children: [
+          /* @__PURE__ */ jsx16(Text16, { children: "Status: " }),
+          steamCmdInstalled === null ? /* @__PURE__ */ jsx16(Text16, { dimColor: true, children: "Checking..." }) : steamCmdInstalled ? /* @__PURE__ */ jsx16(Text16, { color: theme.success, children: "\u25CF Installed" }) : /* @__PURE__ */ jsx16(Text16, { color: theme.warning, children: "\u25CB Not Installed" })
         ] }),
-        steamCmdInstalled && steamCmdPath && /* @__PURE__ */ jsxs10(Box11, { flexShrink: 0, children: [
-          /* @__PURE__ */ jsx11(Text11, { children: "Location: " }),
-          /* @__PURE__ */ jsx11(Text11, { dimColor: true, children: steamCmdPath })
+        steamCmdInstalled && steamCmdPath && /* @__PURE__ */ jsxs15(Box16, { flexShrink: 0, children: [
+          /* @__PURE__ */ jsx16(Text16, { children: "Location: " }),
+          /* @__PURE__ */ jsx16(Text16, { dimColor: true, children: steamCmdPath })
         ] })
       ] })
     ] }),
-    /* @__PURE__ */ jsxs10(Box11, { flexDirection: "column", marginBottom: 1, children: [
-      /* @__PURE__ */ jsx11(Text11, { bold: true, children: "Valheim Dedicated Server" }),
-      /* @__PURE__ */ jsxs10(Box11, { marginLeft: 2, flexDirection: "column", children: [
-        /* @__PURE__ */ jsxs10(Box11, { flexShrink: 0, children: [
-          /* @__PURE__ */ jsx11(Text11, { children: "Status: " }),
-          steamCmdInstalled !== true ? /* @__PURE__ */ jsx11(Text11, { dimColor: true, children: "Waiting for SteamCMD..." }) : valheimInstalled === null ? /* @__PURE__ */ jsx11(Text11, { dimColor: true, children: "Checking..." }) : valheimInstalled ? /* @__PURE__ */ jsx11(Text11, { color: theme.success, children: "\u25CF Installed" }) : /* @__PURE__ */ jsx11(Text11, { color: theme.warning, children: "\u25CB Not Installed" })
+    /* @__PURE__ */ jsxs15(Box16, { flexDirection: "column", marginBottom: 1, children: [
+      /* @__PURE__ */ jsx16(Text16, { bold: true, children: "Valheim Dedicated Server" }),
+      /* @__PURE__ */ jsxs15(Box16, { marginLeft: 2, flexDirection: "column", children: [
+        /* @__PURE__ */ jsxs15(Box16, { flexShrink: 0, children: [
+          /* @__PURE__ */ jsx16(Text16, { children: "Status: " }),
+          steamCmdInstalled !== true ? /* @__PURE__ */ jsx16(Text16, { dimColor: true, children: "Waiting for SteamCMD..." }) : valheimInstalled === null ? /* @__PURE__ */ jsx16(Text16, { dimColor: true, children: "Checking..." }) : valheimInstalled ? /* @__PURE__ */ jsx16(Text16, { color: theme.success, children: "\u25CF Installed" }) : /* @__PURE__ */ jsx16(Text16, { color: theme.warning, children: "\u25CB Not Installed" })
         ] }),
-        valheimInstalled && valheimVerified !== null && /* @__PURE__ */ jsxs10(Box11, { flexShrink: 0, children: [
-          /* @__PURE__ */ jsx11(Text11, { children: "Verified: " }),
-          valheimVerified ? /* @__PURE__ */ jsx11(Text11, { color: theme.success, children: "\u25CF Yes" }) : /* @__PURE__ */ jsx11(Text11, { color: theme.error, children: "\u25CB Files Missing" })
+        valheimInstalled && valheimVerified !== null && /* @__PURE__ */ jsxs15(Box16, { flexShrink: 0, children: [
+          /* @__PURE__ */ jsx16(Text16, { children: "Verified: " }),
+          valheimVerified ? /* @__PURE__ */ jsx16(Text16, { color: theme.success, children: "\u25CF Yes" }) : /* @__PURE__ */ jsx16(Text16, { color: theme.error, children: "\u25CB Files Missing" })
         ] }),
-        valheimInstalled && valheimBuildId && /* @__PURE__ */ jsxs10(Box11, { flexShrink: 0, children: [
-          /* @__PURE__ */ jsx11(Text11, { children: "Build ID: " }),
-          /* @__PURE__ */ jsx11(Text11, { dimColor: true, children: valheimBuildId })
+        valheimInstalled && valheimBuildId && /* @__PURE__ */ jsxs15(Box16, { flexShrink: 0, children: [
+          /* @__PURE__ */ jsx16(Text16, { children: "Build ID: " }),
+          /* @__PURE__ */ jsx16(Text16, { dimColor: true, children: valheimBuildId })
         ] }),
-        valheimInstalled && valheimPath && /* @__PURE__ */ jsxs10(Box11, { flexShrink: 0, children: [
-          /* @__PURE__ */ jsx11(Text11, { children: "Location: " }),
-          /* @__PURE__ */ jsx11(Text11, { dimColor: true, children: valheimPath })
+        valheimInstalled && valheimPath && /* @__PURE__ */ jsxs15(Box16, { flexShrink: 0, children: [
+          /* @__PURE__ */ jsx16(Text16, { children: "Location: " }),
+          /* @__PURE__ */ jsx16(Text16, { dimColor: true, children: valheimPath })
         ] })
       ] })
     ] }),
-    /* @__PURE__ */ jsxs10(Box11, { flexDirection: "column", marginBottom: 1, children: [
-      /* @__PURE__ */ jsx11(Text11, { bold: true, children: "Server Status" }),
-      /* @__PURE__ */ jsxs10(Box11, { marginLeft: 2, flexDirection: "column", children: [
-        /* @__PURE__ */ jsxs10(Box11, { flexShrink: 0, children: [
-          /* @__PURE__ */ jsx11(Text11, { children: "Status: " }),
+    /* @__PURE__ */ jsxs15(Box16, { flexDirection: "column", marginBottom: 1, children: [
+      /* @__PURE__ */ jsx16(Text16, { bold: true, children: "Server Status" }),
+      /* @__PURE__ */ jsxs15(Box16, { marginLeft: 2, flexDirection: "column", children: [
+        /* @__PURE__ */ jsxs15(Box16, { flexShrink: 0, children: [
+          /* @__PURE__ */ jsx16(Text16, { children: "Status: " }),
           renderStatusWithLoading()
         ] }),
-        /* @__PURE__ */ jsxs10(Box11, { flexShrink: 0, children: [
-          /* @__PURE__ */ jsx11(Text11, { children: "Server Name: " }),
-          /* @__PURE__ */ jsx11(Text11, { color: theme.primary, children: config.serverName })
+        /* @__PURE__ */ jsxs15(Box16, { flexShrink: 0, children: [
+          /* @__PURE__ */ jsx16(Text16, { children: "Server Name: " }),
+          /* @__PURE__ */ jsx16(Text16, { color: theme.primary, children: config.serverName })
+        ] }),
+        /* @__PURE__ */ jsxs15(Box16, { flexShrink: 0, children: [
+          /* @__PURE__ */ jsx16(Text16, { children: "World: " }),
+          /* @__PURE__ */ jsx16(Text16, { color: theme.primary, children: config.world })
         ] }),
-        /* @__PURE__ */ jsxs10(Box11, { flexShrink: 0, children: [
-          /* @__PURE__ */ jsx11(Text11, { children: "World: " }),
-          /* @__PURE__ */ jsx11(Text11, { color: theme.primary, children: config.world })
+        /* @__PURE__ */ jsxs15(Box16, { flexShrink: 0, children: [
+          /* @__PURE__ */ jsx16(Text16, { children: "Port: " }),
+          /* @__PURE__ */ jsx16(Text16, { children: config.port })
         ] }),
-        /* @__PURE__ */ jsxs10(Box11, { flexShrink: 0, children: [
-          /* @__PURE__ */ jsx11(Text11, { children: "Port: " }),
-          /* @__PURE__ */ jsx11(Text11, { children: config.port })
+        version && /* @__PURE__ */ jsxs15(Box16, { flexShrink: 0, children: [
+          /* @__PURE__ */ jsx16(Text16, { children: "Version: " }),
+          /* @__PURE__ */ jsx16(Text16, { children: version }),
+          updateAvailable && /* @__PURE__ */ jsx16(Text16, { color: theme.warning, children: " (Update available!)" })
         ] }),
-        version && /* @__PURE__ */ jsxs10(Box11, { flexShrink: 0, children: [
-          /* @__PURE__ */ jsx11(Text11, { children: "Version: " }),
-          /* @__PURE__ */ jsx11(Text11, { children: version }),
-          updateAvailable && /* @__PURE__ */ jsx11(Text11, { color: theme.warning, children: " (Update available!)" })
+        pid && /* @__PURE__ */ jsxs15(Box16, { flexShrink: 0, children: [
+          /* @__PURE__ */ jsx16(Text16, { children: "PID: " }),
+          /* @__PURE__ */ jsx16(Text16, { dimColor: true, children: pid })
         ] }),
-        pid && /* @__PURE__ */ jsxs10(Box11, { flexShrink: 0, children: [
-          /* @__PURE__ */ jsx11(Text11, { children: "PID: " }),
-          /* @__PURE__ */ jsx11(Text11, { dimColor: true, children: pid })
+        /* @__PURE__ */ jsxs15(Box16, { flexShrink: 0, children: [
+          /* @__PURE__ */ jsx16(Text16, { children: "Uptime: " }),
+          /* @__PURE__ */ jsx16(Text16, { children: formatUptime2(uptime) })
         ] }),
-        /* @__PURE__ */ jsxs10(Box11, { flexShrink: 0, children: [
-          /* @__PURE__ */ jsx11(Text11, { children: "Uptime: " }),
-          /* @__PURE__ */ jsx11(Text11, { children: formatUptime2(uptime) })
+        /* @__PURE__ */ jsxs15(Box16, { flexShrink: 0, children: [
+          /* @__PURE__ */ jsx16(Text16, { children: "Last Save: " }),
+          /* @__PURE__ */ jsx16(Text16, { children: formatLastSave(lastSave) })
         ] }),
-        /* @__PURE__ */ jsxs10(Box11, { flexShrink: 0, children: [
-          /* @__PURE__ */ jsx11(Text11, { children: "Last Save: " }),
-          /* @__PURE__ */ jsx11(Text11, { children: formatLastSave(lastSave) })
+        memoryUsage !== null && memoryUsage > 0 && /* @__PURE__ */ jsxs15(Box16, { flexShrink: 0, children: [
+          /* @__PURE__ */ jsx16(Text16, { children: "Memory: " }),
+          /* @__PURE__ */ jsx16(Text16, { children: formatBytes(memoryUsage) })
+        ] })
+      ] })
+    ] }),
+    /* @__PURE__ */ jsxs15(Box16, { flexDirection: "column", marginBottom: 1, children: [
+      /* @__PURE__ */ jsx16(Text16, { bold: true, children: "RCON Status" }),
+      /* @__PURE__ */ jsxs15(Box16, { marginLeft: 2, flexDirection: "column", children: [
+        /* @__PURE__ */ jsxs15(Box16, { flexShrink: 0, children: [
+          /* @__PURE__ */ jsx16(Text16, { children: "RCON: " }),
+          rconConfig.enabled ? rconConnected ? /* @__PURE__ */ jsx16(Text16, { color: theme.success, children: "\u25CF Connected" }) : status === "online" ? /* @__PURE__ */ jsx16(Text16, { color: theme.warning, children: "\u25CB Connecting..." }) : /* @__PURE__ */ jsx16(Text16, { dimColor: true, children: "\u25CB Waiting for server..." }) : /* @__PURE__ */ jsx16(Text16, { dimColor: true, children: "\u25CB Disabled" })
         ] }),
-        memoryUsage !== null && memoryUsage > 0 && /* @__PURE__ */ jsxs10(Box11, { flexShrink: 0, children: [
-          /* @__PURE__ */ jsx11(Text11, { children: "Memory: " }),
-          /* @__PURE__ */ jsx11(Text11, { children: formatBytes(memoryUsage) })
+        rconConfig.enabled && /* @__PURE__ */ jsxs15(Fragment4, { children: [
+          /* @__PURE__ */ jsxs15(Box16, { flexShrink: 0, children: [
+            /* @__PURE__ */ jsx16(Text16, { children: "Port: " }),
+            /* @__PURE__ */ jsx16(Text16, { dimColor: true, children: rconConfig.port })
+          ] }),
+          /* @__PURE__ */ jsxs15(Box16, { flexShrink: 0, children: [
+            /* @__PURE__ */ jsx16(Text16, { children: "Auto-reconnect: " }),
+            /* @__PURE__ */ jsx16(Text16, { dimColor: true, children: rconConfig.autoReconnect ? "Enabled" : "Disabled" })
+          ] })
         ] })
       ] })
     ] }),
-    /* @__PURE__ */ jsxs10(Box11, { flexDirection: "column", marginBottom: 1, children: [
-      /* @__PURE__ */ jsxs10(Text11, { bold: true, children: [
+    /* @__PURE__ */ jsxs15(Box16, { flexDirection: "column", marginBottom: 1, children: [
+      /* @__PURE__ */ jsxs15(Text16, { bold: true, children: [
         "Players (",
         players.length,
         ")"
       ] }),
-      /* @__PURE__ */ jsx11(Box11, { marginLeft: 2, flexDirection: "column", children: players.length === 0 ? /* @__PURE__ */ jsx11(Text11, { dimColor: true, children: "No players connected" }) : players.map((player) => /* @__PURE__ */ jsx11(Box11, { flexShrink: 0, children: /* @__PURE__ */ jsxs10(Text11, { color: theme.primary, children: [
+      /* @__PURE__ */ jsx16(Box16, { marginLeft: 2, flexDirection: "column", children: players.length === 0 ? /* @__PURE__ */ jsx16(Text16, { dimColor: true, children: "No players connected" }) : players.map((player) => /* @__PURE__ */ jsx16(Box16, { flexShrink: 0, children: /* @__PURE__ */ jsxs15(Text16, { color: theme.primary, children: [
         "\u2022 ",
         player
       ] }) }, player)) })
     ] }),
-    /* @__PURE__ */ jsxs10(Box11, { flexDirection: "column", marginBottom: 1, children: [
-      /* @__PURE__ */ jsx11(Text11, { bold: true, children: "Auto-start" }),
-      /* @__PURE__ */ jsxs10(Box11, { marginLeft: 2, flexShrink: 0, children: [
-        /* @__PURE__ */ jsx11(Text11, { children: "Status: " }),
-        startupTaskRegistered === null ? /* @__PURE__ */ jsx11(Text11, { dimColor: true, children: "Checking..." }) : startupTaskRegistered ? /* @__PURE__ */ jsx11(Text11, { color: theme.success, children: "\u25CF Enabled" }) : /* @__PURE__ */ jsx11(Text11, { dimColor: true, children: "\u25CB Disabled" })
+    /* @__PURE__ */ jsxs15(Box16, { flexDirection: "column", marginBottom: 1, children: [
+      /* @__PURE__ */ jsx16(Text16, { bold: true, children: "Auto-start" }),
+      /* @__PURE__ */ jsxs15(Box16, { marginLeft: 2, flexShrink: 0, children: [
+        /* @__PURE__ */ jsx16(Text16, { children: "Status: " }),
+        startupTaskRegistered === null ? /* @__PURE__ */ jsx16(Text16, { dimColor: true, children: "Checking..." }) : startupTaskRegistered ? /* @__PURE__ */ jsx16(Text16, { color: theme.success, children: "\u25CF Enabled" }) : /* @__PURE__ */ jsx16(Text16, { dimColor: true, children: "\u25CB Disabled" })
       ] })
     ] }),
-    /* @__PURE__ */ jsxs10(Box11, { flexDirection: "column", children: [
-      /* @__PURE__ */ jsx11(Text11, { bold: true, children: "Quick Actions" }),
-      /* @__PURE__ */ jsxs10(Box11, { marginLeft: 2, marginTop: 1, flexDirection: "column", children: [
-        steamCmdInstalled === false && /* @__PURE__ */ jsx11(Box11, { marginBottom: 1, flexShrink: 0, children: /* @__PURE__ */ jsxs10(Box11, { flexShrink: 0, children: [
-          /* @__PURE__ */ jsx11(Text11, { color: theme.info, children: "[I] " }),
-          /* @__PURE__ */ jsx11(Text11, { children: "Install SteamCMD" }),
-          /* @__PURE__ */ jsx11(Text11, { color: theme.warning, children: " (required)" })
+    /* @__PURE__ */ jsxs15(Box16, { flexDirection: "column", children: [
+      /* @__PURE__ */ jsx16(Text16, { bold: true, children: "Quick Actions" }),
+      /* @__PURE__ */ jsxs15(Box16, { marginLeft: 2, marginTop: 1, flexDirection: "column", children: [
+        steamCmdInstalled === false && /* @__PURE__ */ jsx16(Box16, { marginBottom: 1, flexShrink: 0, children: /* @__PURE__ */ jsxs15(Box16, { flexShrink: 0, children: [
+          /* @__PURE__ */ jsx16(Text16, { color: theme.info, children: "[I] " }),
+          /* @__PURE__ */ jsx16(Text16, { children: "Install SteamCMD" }),
+          /* @__PURE__ */ jsx16(Text16, { color: theme.warning, children: " (required)" })
         ] }) }),
-        steamCmdInstalled && valheimInstalled === false && !valheimInstalling && /* @__PURE__ */ jsx11(Box11, { marginBottom: 1, flexShrink: 0, children: /* @__PURE__ */ jsxs10(Box11, { flexShrink: 0, children: [
-          /* @__PURE__ */ jsx11(Text11, { color: theme.info, children: "[V] " }),
-          /* @__PURE__ */ jsx11(Text11, { children: "Install Valheim Server" }),
-          /* @__PURE__ */ jsx11(Text11, { color: theme.warning, children: " (required)" })
+        steamCmdInstalled && valheimInstalled === false && !valheimInstalling && /* @__PURE__ */ jsx16(Box16, { marginBottom: 1, flexShrink: 0, children: /* @__PURE__ */ jsxs15(Box16, { flexShrink: 0, children: [
+          /* @__PURE__ */ jsx16(Text16, { color: theme.info, children: "[V] " }),
+          /* @__PURE__ */ jsx16(Text16, { children: "Install Valheim Server" }),
+          /* @__PURE__ */ jsx16(Text16, { color: theme.warning, children: " (required)" })
         ] }) }),
-        steamCmdInstalled && valheimInstalled && valheimVerified === false && /* @__PURE__ */ jsx11(Box11, { marginBottom: 1, flexShrink: 0, children: /* @__PURE__ */ jsxs10(Box11, { flexShrink: 0, children: [
-          /* @__PURE__ */ jsx11(Text11, { color: theme.warning, children: "[V] " }),
-          /* @__PURE__ */ jsx11(Text11, { children: "Reinstall Valheim Server" }),
-          /* @__PURE__ */ jsx11(Text11, { color: theme.error, children: " (verification failed)" })
+        steamCmdInstalled && valheimInstalled && valheimVerified === false && /* @__PURE__ */ jsx16(Box16, { marginBottom: 1, flexShrink: 0, children: /* @__PURE__ */ jsxs15(Box16, { flexShrink: 0, children: [
+          /* @__PURE__ */ jsx16(Text16, { color: theme.warning, children: "[V] " }),
+          /* @__PURE__ */ jsx16(Text16, { children: "Reinstall Valheim Server" }),
+          /* @__PURE__ */ jsx16(Text16, { color: theme.error, children: " (verification failed)" })
         ] }) }),
-        steamCmdInstalled && valheimInstalled ? status === "offline" ? /* @__PURE__ */ jsxs10(Box11, { flexDirection: "column", children: [
-          /* @__PURE__ */ jsxs10(Box11, { flexShrink: 0, children: [
-            /* @__PURE__ */ jsx11(Text11, { color: theme.success, children: "[S] " }),
-            /* @__PURE__ */ jsx11(Text11, { children: "Start Server" })
+        steamCmdInstalled && valheimInstalled ? status === "offline" ? /* @__PURE__ */ jsxs15(Box16, { flexDirection: "column", children: [
+          /* @__PURE__ */ jsxs15(Box16, { flexShrink: 0, children: [
+            /* @__PURE__ */ jsx16(Text16, { color: theme.success, children: "[S] " }),
+            /* @__PURE__ */ jsx16(Text16, { children: "Start Server" })
           ] }),
-          /* @__PURE__ */ jsxs10(Box11, { flexShrink: 0, children: [
-            /* @__PURE__ */ jsx11(Text11, { color: theme.info, children: "[U] " }),
-            /* @__PURE__ */ jsx11(Text11, { children: "Update Server" }),
-            updateAvailable && /* @__PURE__ */ jsx11(Text11, { color: theme.warning, children: " \u2605" })
+          /* @__PURE__ */ jsxs15(Box16, { flexShrink: 0, children: [
+            /* @__PURE__ */ jsx16(Text16, { color: theme.info, children: "[U] " }),
+            /* @__PURE__ */ jsx16(Text16, { children: "Update Server" }),
+            updateAvailable && /* @__PURE__ */ jsx16(Text16, { color: theme.warning, children: " \u2605" })
           ] }),
-          /* @__PURE__ */ jsxs10(Box11, { flexShrink: 0, children: [
-            /* @__PURE__ */ jsx11(Text11, { color: theme.info, children: "[V] " }),
-            /* @__PURE__ */ jsx11(Text11, { dimColor: true, children: "Verify/Reinstall Server" })
+          /* @__PURE__ */ jsxs15(Box16, { flexShrink: 0, children: [
+            /* @__PURE__ */ jsx16(Text16, { color: theme.info, children: "[V] " }),
+            /* @__PURE__ */ jsx16(Text16, { dimColor: true, children: "Verify/Reinstall Server" })
           ] })
-        ] }) : status === "online" ? /* @__PURE__ */ jsxs10(Box11, { flexDirection: "column", children: [
-          /* @__PURE__ */ jsxs10(Box11, { flexShrink: 0, children: [
-            /* @__PURE__ */ jsx11(Text11, { color: theme.error, children: "[X] " }),
-            /* @__PURE__ */ jsx11(Text11, { children: "Stop Server" })
+        ] }) : status === "online" ? /* @__PURE__ */ jsxs15(Box16, { flexDirection: "column", children: [
+          /* @__PURE__ */ jsxs15(Box16, { flexShrink: 0, children: [
+            /* @__PURE__ */ jsx16(Text16, { color: theme.error, children: "[X] " }),
+            /* @__PURE__ */ jsx16(Text16, { children: "Stop Server" })
+          ] }),
+          /* @__PURE__ */ jsxs15(Box16, { flexShrink: 0, children: [
+            /* @__PURE__ */ jsx16(Text16, { color: theme.warning, children: "[R] " }),
+            /* @__PURE__ */ jsx16(Text16, { children: "Restart Server" })
           ] }),
-          /* @__PURE__ */ jsxs10(Box11, { flexShrink: 0, children: [
-            /* @__PURE__ */ jsx11(Text11, { color: theme.warning, children: "[R] " }),
-            /* @__PURE__ */ jsx11(Text11, { children: "Restart Server" })
+          /* @__PURE__ */ jsxs15(Box16, { flexShrink: 0, children: [
+            /* @__PURE__ */ jsx16(Text16, { color: theme.info, children: "[F] " }),
+            /* @__PURE__ */ jsx16(Text16, { children: "Force Save" })
           ] }),
-          /* @__PURE__ */ jsxs10(Box11, { flexShrink: 0, children: [
-            /* @__PURE__ */ jsx11(Text11, { color: theme.info, children: "[F] " }),
-            /* @__PURE__ */ jsx11(Text11, { children: "Force Save" })
+          /* @__PURE__ */ jsxs15(Box16, { flexShrink: 0, children: [
+            /* @__PURE__ */ jsx16(Text16, { color: theme.error, children: "[K] " }),
+            /* @__PURE__ */ jsx16(Text16, { children: "Kill Process" })
           ] }),
-          /* @__PURE__ */ jsxs10(Box11, { flexShrink: 0, children: [
-            /* @__PURE__ */ jsx11(Text11, { color: theme.error, children: "[K] " }),
-            /* @__PURE__ */ jsx11(Text11, { children: "Kill Process" })
+          rconConnected && /* @__PURE__ */ jsxs15(Fragment4, { children: [
+            /* @__PURE__ */ jsx16(Box16, { marginTop: 1, flexShrink: 0, children: /* @__PURE__ */ jsx16(Text16, { bold: true, color: theme.primary, children: "RCON Admin:" }) }),
+            /* @__PURE__ */ jsxs15(Box16, { flexShrink: 0, children: [
+              /* @__PURE__ */ jsx16(Text16, { color: theme.primary, children: "[P] " }),
+              /* @__PURE__ */ jsx16(Text16, { children: "Player Manager" })
+            ] }),
+            /* @__PURE__ */ jsxs15(Box16, { flexShrink: 0, children: [
+              /* @__PURE__ */ jsx16(Text16, { color: theme.info, children: "[N] " }),
+              /* @__PURE__ */ jsx16(Text16, { children: "Server Info" })
+            ] }),
+            /* @__PURE__ */ jsxs15(Box16, { flexShrink: 0, children: [
+              /* @__PURE__ */ jsx16(Text16, { color: theme.warning, children: "[E] " }),
+              /* @__PURE__ */ jsx16(Text16, { children: "Event Manager" })
+            ] }),
+            /* @__PURE__ */ jsxs15(Box16, { flexShrink: 0, children: [
+              /* @__PURE__ */ jsx16(Text16, { color: theme.info, children: "[T] " }),
+              /* @__PURE__ */ jsx16(Text16, { children: "Time Control" })
+            ] }),
+            /* @__PURE__ */ jsxs15(Box16, { flexShrink: 0, children: [
+              /* @__PURE__ */ jsx16(Text16, { color: theme.primary, children: "[G] " }),
+              /* @__PURE__ */ jsx16(Text16, { children: "Boss Progress" })
+            ] }),
+            /* @__PURE__ */ jsxs15(Box16, { flexShrink: 0, children: [
+              /* @__PURE__ */ jsx16(Text16, { color: theme.error, children: "[D] " }),
+              /* @__PURE__ */ jsx16(Text16, { children: "Remove Drops" })
+            ] })
           ] })
-        ] }) : /* @__PURE__ */ jsxs10(Box11, { flexDirection: "column", children: [
-          /* @__PURE__ */ jsx11(Spinner, { label: `Server is ${status}...` }),
-          /* @__PURE__ */ jsxs10(Box11, { marginTop: 1, flexShrink: 0, children: [
-            /* @__PURE__ */ jsx11(Text11, { color: theme.error, children: "[K] " }),
-            /* @__PURE__ */ jsx11(Text11, { dimColor: true, children: "Force Kill (if stuck)" })
+        ] }) : /* @__PURE__ */ jsxs15(Box16, { flexDirection: "column", children: [
+          /* @__PURE__ */ jsx16(Spinner, { label: `Server is ${status}...` }),
+          /* @__PURE__ */ jsxs15(Box16, { marginTop: 1, flexShrink: 0, children: [
+            /* @__PURE__ */ jsx16(Text16, { color: theme.error, children: "[K] " }),
+            /* @__PURE__ */ jsx16(Text16, { dimColor: true, children: "Force Kill (if stuck)" })
           ] })
-        ] }) : steamCmdInstalled === null ? /* @__PURE__ */ jsx11(Text11, { dimColor: true, children: "Checking installation status..." }) : !steamCmdInstalled ? /* @__PURE__ */ jsx11(Text11, { dimColor: true, children: "Install SteamCMD to manage server" }) : valheimInstalled === null ? /* @__PURE__ */ jsx11(Text11, { dimColor: true, children: "Checking Valheim installation..." }) : /* @__PURE__ */ jsx11(Text11, { dimColor: true, children: "Install Valheim to manage server" }),
-        /* @__PURE__ */ jsx11(Box11, { marginTop: 1, flexShrink: 0, children: startupTaskProcessing ? /* @__PURE__ */ jsx11(Spinner, { label: "Updating auto-start..." }) : startupTaskRegistered === null ? /* @__PURE__ */ jsx11(Text11, { dimColor: true, children: "Checking auto-start status..." }) : /* @__PURE__ */ jsxs10(Box11, { flexShrink: 0, children: [
-          /* @__PURE__ */ jsxs10(
-            Text11,
+        ] }) : steamCmdInstalled === null ? /* @__PURE__ */ jsx16(Text16, { dimColor: true, children: "Checking installation status..." }) : !steamCmdInstalled ? /* @__PURE__ */ jsx16(Text16, { dimColor: true, children: "Install SteamCMD to manage server" }) : valheimInstalled === null ? /* @__PURE__ */ jsx16(Text16, { dimColor: true, children: "Checking Valheim installation..." }) : /* @__PURE__ */ jsx16(Text16, { dimColor: true, children: "Install Valheim to manage server" }),
+        /* @__PURE__ */ jsx16(Box16, { marginTop: 1, flexShrink: 0, children: startupTaskProcessing ? /* @__PURE__ */ jsx16(Spinner, { label: "Updating auto-start..." }) : startupTaskRegistered === null ? /* @__PURE__ */ jsx16(Text16, { dimColor: true, children: "Checking auto-start status..." }) : /* @__PURE__ */ jsxs15(Box16, { flexShrink: 0, children: [
+          /* @__PURE__ */ jsxs15(
+            Text16,
             {
               color: startupTaskRegistered ? theme.warning : theme.success,
               children: [
@@ -44149,7 +46007,7 @@ var Dashboard = () => {
               ]
             }
           ),
-          /* @__PURE__ */ jsxs10(Text11, { children: [
+          /* @__PURE__ */ jsxs15(Text16, { children: [
             startupTaskRegistered ? "Disable" : "Enable",
             " Auto-start"
           ] })
@@ -44160,13 +46018,13 @@ var Dashboard = () => {
 };
 
 // src/tui/screens/Settings.tsx
-import { Box as Box15, Text as Text15, useInput as useInput8 } from "ink";
-import { useCallback as useCallback5, useMemo as useMemo4, useState as useState10 } from "react";
+import { Box as Box20, Text as Text20, useInput as useInput13 } from "ink";
+import { useCallback as useCallback5, useMemo as useMemo4, useState as useState15 } from "react";
 
 // src/tui/components/NumberInput.tsx
-import { Box as Box12, Text as Text12, useInput as useInput5 } from "ink";
-import { useEffect as useEffect8, useState as useState7 } from "react";
-import { jsx as jsx12, jsxs as jsxs11 } from "react/jsx-runtime";
+import { Box as Box17, Text as Text17, useInput as useInput10 } from "ink";
+import { useEffect as useEffect10, useState as useState12 } from "react";
+import { jsx as jsx17, jsxs as jsxs16 } from "react/jsx-runtime";
 var NumberInput = ({
   value,
   onChange,
@@ -44180,15 +46038,15 @@ var NumberInput = ({
   label,
   width = 10
 }) => {
-  const [editMode, setEditMode] = useState7(false);
-  const [editBuffer, setEditBuffer] = useState7("");
-  const [cursorVisible, setCursorVisible] = useState7(true);
-  useEffect8(() => {
+  const [editMode, setEditMode] = useState12(false);
+  const [editBuffer, setEditBuffer] = useState12("");
+  const [cursorVisible, setCursorVisible] = useState12(true);
+  useEffect10(() => {
     if (editMode) {
       setEditBuffer(String(value));
     }
   }, [editMode, value]);
-  useEffect8(() => {
+  useEffect10(() => {
     if (!focus || !editMode) {
       setCursorVisible(false);
       return;
@@ -44209,7 +46067,7 @@ var NumberInput = ({
     }
     setEditMode(false);
   };
-  useInput5(
+  useInput10(
     (input, key) => {
       if (!focus) return;
       if (key.escape) {
@@ -44280,38 +46138,38 @@ var NumberInput = ({
   const padding = " ".repeat(paddingLength);
   const atMin = value <= min;
   const atMax = value >= max;
-  return /* @__PURE__ */ jsxs11(Box12, { children: [
-    label && /* @__PURE__ */ jsx12(Box12, { marginRight: 1, children: /* @__PURE__ */ jsxs11(Text12, { children: [
+  return /* @__PURE__ */ jsxs16(Box17, { children: [
+    label && /* @__PURE__ */ jsx17(Box17, { marginRight: 1, children: /* @__PURE__ */ jsxs16(Text17, { children: [
       label,
       ":"
     ] }) }),
-    /* @__PURE__ */ jsxs11(Box12, { children: [
-      focus && !editMode && /* @__PURE__ */ jsx12(Text12, { color: atMin ? theme.muted : theme.primary, children: atMin ? " " : "\u25C0" }),
-      /* @__PURE__ */ jsx12(
-        Box12,
+    /* @__PURE__ */ jsxs16(Box17, { children: [
+      focus && !editMode && /* @__PURE__ */ jsx17(Text17, { color: atMin ? theme.muted : theme.primary, children: atMin ? " " : "\u25C0" }),
+      /* @__PURE__ */ jsx17(
+        Box17,
         {
           borderStyle: editMode ? "single" : void 0,
           borderColor: editMode ? theme.primary : void 0,
           marginX: focus && !editMode ? 1 : 0,
-          children: /* @__PURE__ */ jsxs11(Text12, { color: focus ? theme.primary : void 0, bold: focus, children: [
+          children: /* @__PURE__ */ jsxs16(Text17, { color: focus ? theme.primary : void 0, bold: focus, children: [
             displayValue,
-            editMode && cursorVisible && /* @__PURE__ */ jsx12(Text12, { inverse: true, children: " " }),
-            suffix && /* @__PURE__ */ jsx12(Text12, { dimColor: true, children: suffix }),
+            editMode && cursorVisible && /* @__PURE__ */ jsx17(Text17, { inverse: true, children: " " }),
+            suffix && /* @__PURE__ */ jsx17(Text17, { dimColor: true, children: suffix }),
             padding
           ] })
         }
       ),
-      focus && !editMode && /* @__PURE__ */ jsx12(Text12, { color: atMax ? theme.muted : theme.primary, children: atMax ? " " : "\u25B6" })
+      focus && !editMode && /* @__PURE__ */ jsx17(Text17, { color: atMax ? theme.muted : theme.primary, children: atMax ? " " : "\u25B6" })
     ] }),
-    focus && !editMode && /* @__PURE__ */ jsx12(Box12, { marginLeft: 1, children: /* @__PURE__ */ jsx12(Text12, { dimColor: true, children: "[\u2191/\u2193 or type]" }) }),
-    editMode && /* @__PURE__ */ jsx12(Box12, { marginLeft: 1, children: /* @__PURE__ */ jsx12(Text12, { dimColor: true, children: "[Enter to save, Esc to cancel]" }) })
+    focus && !editMode && /* @__PURE__ */ jsx17(Box17, { marginLeft: 1, children: /* @__PURE__ */ jsx17(Text17, { dimColor: true, children: "[\u2191/\u2193 or type]" }) }),
+    editMode && /* @__PURE__ */ jsx17(Box17, { marginLeft: 1, children: /* @__PURE__ */ jsx17(Text17, { dimColor: true, children: "[Enter to save, Esc to cancel]" }) })
   ] });
 };
 
 // src/tui/components/SelectInput.tsx
-import { Box as Box13, Text as Text13, useInput as useInput6 } from "ink";
-import { useMemo as useMemo3, useState as useState8 } from "react";
-import { jsx as jsx13, jsxs as jsxs12 } from "react/jsx-runtime";
+import { Box as Box18, Text as Text18, useInput as useInput11 } from "ink";
+import { useMemo as useMemo3, useState as useState13 } from "react";
+import { jsx as jsx18, jsxs as jsxs17 } from "react/jsx-runtime";
 function SelectInput({
   options,
   value,
@@ -44324,12 +46182,12 @@ function SelectInput({
   maxVisible = 5,
   expanded: initialExpanded = false
 }) {
-  const [expanded, setExpanded] = useState8(initialExpanded);
-  const [highlightIndex, setHighlightIndex] = useState8(() => {
+  const [expanded, setExpanded] = useState13(initialExpanded);
+  const [highlightIndex, setHighlightIndex] = useState13(() => {
     const idx = options.findIndex((opt) => opt.value === value);
     return idx >= 0 ? idx : 0;
   });
-  const [filter, setFilter] = useState8("");
+  const [filter, setFilter] = useState13("");
   const filteredOptions = useMemo3(() => {
     if (!filter) return options;
     const lowerFilter = filter.toLowerCase();
@@ -44349,7 +46207,7 @@ function SelectInput({
   );
   const selectedOption = options.find((opt) => opt.value === value);
   const displayLabel = selectedOption?.label ?? placeholder;
-  useInput6(
+  useInput11(
     (input, key) => {
       if (!focus) return;
       if (!expanded) {
@@ -44426,23 +46284,23 @@ function SelectInput({
     },
     { isActive: focus }
   );
-  return /* @__PURE__ */ jsxs12(Box13, { flexDirection: "column", children: [
-    /* @__PURE__ */ jsxs12(Box13, { children: [
-      label && /* @__PURE__ */ jsx13(Box13, { marginRight: 1, children: /* @__PURE__ */ jsxs12(Text13, { children: [
+  return /* @__PURE__ */ jsxs17(Box18, { flexDirection: "column", children: [
+    /* @__PURE__ */ jsxs17(Box18, { children: [
+      label && /* @__PURE__ */ jsx18(Box18, { marginRight: 1, children: /* @__PURE__ */ jsxs17(Text18, { children: [
         label,
         ":"
       ] }) }),
-      /* @__PURE__ */ jsxs12(Box13, { children: [
-        /* @__PURE__ */ jsx13(Text13, { color: focus ? theme.primary : void 0, bold: focus, children: displayLabel }),
-        /* @__PURE__ */ jsxs12(Text13, { dimColor: true, children: [
+      /* @__PURE__ */ jsxs17(Box18, { children: [
+        /* @__PURE__ */ jsx18(Text18, { color: focus ? theme.primary : void 0, bold: focus, children: displayLabel }),
+        /* @__PURE__ */ jsxs17(Text18, { dimColor: true, children: [
           " ",
           expanded ? "\u25B2" : "\u25BC"
         ] })
       ] }),
-      focus && !expanded && /* @__PURE__ */ jsx13(Box13, { marginLeft: 1, children: /* @__PURE__ */ jsx13(Text13, { dimColor: true, children: "[Enter to expand, \u2191/\u2193 to change]" }) })
+      focus && !expanded && /* @__PURE__ */ jsx18(Box18, { marginLeft: 1, children: /* @__PURE__ */ jsx18(Text18, { dimColor: true, children: "[Enter to expand, \u2191/\u2193 to change]" }) })
     ] }),
-    expanded && /* @__PURE__ */ jsxs12(
-      Box13,
+    expanded && /* @__PURE__ */ jsxs17(
+      Box18,
       {
         flexDirection: "column",
         marginTop: 1,
@@ -44450,22 +46308,22 @@ function SelectInput({
         borderColor: theme.primary,
         paddingX: 1,
         children: [
-          filter && /* @__PURE__ */ jsxs12(Box13, { marginBottom: 1, children: [
-            /* @__PURE__ */ jsx13(Text13, { dimColor: true, children: "Filter: " }),
-            /* @__PURE__ */ jsx13(Text13, { color: theme.primary, children: filter })
+          filter && /* @__PURE__ */ jsxs17(Box18, { marginBottom: 1, children: [
+            /* @__PURE__ */ jsx18(Text18, { dimColor: true, children: "Filter: " }),
+            /* @__PURE__ */ jsx18(Text18, { color: theme.primary, children: filter })
           ] }),
-          scrollOffset > 0 && /* @__PURE__ */ jsx13(Box13, { children: /* @__PURE__ */ jsxs12(Text13, { dimColor: true, children: [
+          scrollOffset > 0 && /* @__PURE__ */ jsx18(Box18, { children: /* @__PURE__ */ jsxs17(Text18, { dimColor: true, children: [
             " \u2191 more (",
             scrollOffset,
             ")"
           ] }) }),
-          filteredOptions.length === 0 ? /* @__PURE__ */ jsx13(Box13, { children: /* @__PURE__ */ jsx13(Text13, { dimColor: true, children: "No matches" }) }) : visibleOptions.map((option, visibleIdx) => {
+          filteredOptions.length === 0 ? /* @__PURE__ */ jsx18(Box18, { children: /* @__PURE__ */ jsx18(Text18, { dimColor: true, children: "No matches" }) }) : visibleOptions.map((option, visibleIdx) => {
             const actualIdx = scrollOffset + visibleIdx;
             const isHighlighted = actualIdx === highlightIndex;
             const isSelected = option.value === value;
-            return /* @__PURE__ */ jsxs12(Box13, { paddingY: 0, children: [
-              /* @__PURE__ */ jsxs12(
-                Text13,
+            return /* @__PURE__ */ jsxs17(Box18, { paddingY: 0, children: [
+              /* @__PURE__ */ jsxs17(
+                Text18,
                 {
                   color: isHighlighted ? theme.primary : isSelected ? theme.success : void 0,
                   bold: isHighlighted,
@@ -44476,18 +46334,18 @@ function SelectInput({
                   ]
                 }
               ),
-              option.description && /* @__PURE__ */ jsxs12(Text13, { dimColor: true, children: [
+              option.description && /* @__PURE__ */ jsxs17(Text18, { dimColor: true, children: [
                 " - ",
                 option.description
               ] })
             ] }, String(option.value));
           }),
-          scrollOffset + maxVisible < filteredOptions.length && /* @__PURE__ */ jsx13(Box13, { children: /* @__PURE__ */ jsxs12(Text13, { dimColor: true, children: [
+          scrollOffset + maxVisible < filteredOptions.length && /* @__PURE__ */ jsx18(Box18, { children: /* @__PURE__ */ jsxs17(Text18, { dimColor: true, children: [
             "\u2193 more (",
             filteredOptions.length - scrollOffset - maxVisible,
             ")"
           ] }) }),
-          /* @__PURE__ */ jsx13(Box13, { marginTop: 1, children: /* @__PURE__ */ jsx13(Text13, { dimColor: true, children: "\u2191/\u2193 navigate \u2022 Enter select \u2022 Esc close \u2022 type to filter" }) })
+          /* @__PURE__ */ jsx18(Box18, { marginTop: 1, children: /* @__PURE__ */ jsx18(Text18, { dimColor: true, children: "\u2191/\u2193 navigate \u2022 Enter select \u2022 Esc close \u2022 type to filter" }) })
         ]
       }
     )
@@ -44495,9 +46353,9 @@ function SelectInput({
 }
 
 // src/tui/components/TextInput.tsx
-import { Box as Box14, Text as Text14, useInput as useInput7 } from "ink";
-import { useEffect as useEffect9, useState as useState9 } from "react";
-import { jsx as jsx14, jsxs as jsxs13 } from "react/jsx-runtime";
+import { Box as Box19, Text as Text19, useInput as useInput12 } from "ink";
+import { useEffect as useEffect11, useState as useState14 } from "react";
+import { jsx as jsx19, jsxs as jsxs18 } from "react/jsx-runtime";
 var TextInput = ({
   value,
   onChange,
@@ -44510,12 +46368,12 @@ var TextInput = ({
   focus = true,
   label
 }) => {
-  const [cursorPosition, setCursorPosition] = useState9(value.length);
-  const [cursorVisible, setCursorVisible] = useState9(true);
-  useEffect9(() => {
+  const [cursorPosition, setCursorPosition] = useState14(value.length);
+  const [cursorVisible, setCursorVisible] = useState14(true);
+  useEffect11(() => {
     setCursorPosition(value.length);
   }, [value.length]);
-  useEffect9(() => {
+  useEffect11(() => {
     if (!focus) {
       setCursorVisible(false);
       return;
@@ -44526,7 +46384,7 @@ var TextInput = ({
     setCursorVisible(true);
     return () => clearInterval(interval);
   }, [focus]);
-  useInput7(
+  useInput12(
     (input, key) => {
       if (!focus) return;
       if (key.return) {
@@ -44582,29 +46440,29 @@ var TextInput = ({
   const paddingLength = Math.max(0, width - contentLength);
   const padding = " ".repeat(paddingLength);
   const showPlaceholder = value.length === 0 && placeholder;
-  return /* @__PURE__ */ jsxs13(Box14, { children: [
-    label && /* @__PURE__ */ jsx14(Box14, { marginRight: 1, children: /* @__PURE__ */ jsxs13(Text14, { children: [
+  return /* @__PURE__ */ jsxs18(Box19, { children: [
+    label && /* @__PURE__ */ jsx19(Box19, { marginRight: 1, children: /* @__PURE__ */ jsxs18(Text19, { children: [
       label,
       ":"
     ] }) }),
-    /* @__PURE__ */ jsx14(
-      Box14,
+    /* @__PURE__ */ jsx19(
+      Box19,
       {
         borderStyle: focus ? "single" : void 0,
         borderColor: focus ? theme.primary : void 0,
         paddingX: focus ? 0 : 0,
-        children: showPlaceholder && !focus ? /* @__PURE__ */ jsx14(Text14, { dimColor: true, children: placeholder }) : /* @__PURE__ */ jsxs13(Text14, { children: [
-          /* @__PURE__ */ jsx14(Text14, { children: beforeCursor }),
-          /* @__PURE__ */ jsx14(
-            Text14,
+        children: showPlaceholder && !focus ? /* @__PURE__ */ jsx19(Text19, { dimColor: true, children: placeholder }) : /* @__PURE__ */ jsxs18(Text19, { children: [
+          /* @__PURE__ */ jsx19(Text19, { children: beforeCursor }),
+          /* @__PURE__ */ jsx19(
+            Text19,
             {
               inverse: focus && cursorVisible,
               color: focus ? theme.primary : void 0,
               children: cursorChar
             }
           ),
-          /* @__PURE__ */ jsx14(Text14, { children: afterCursor }),
-          /* @__PURE__ */ jsx14(Text14, { children: padding })
+          /* @__PURE__ */ jsx19(Text19, { children: afterCursor }),
+          /* @__PURE__ */ jsx19(Text19, { children: padding })
         ] })
       }
     )
@@ -44612,7 +46470,7 @@ var TextInput = ({
 };
 
 // src/tui/hooks/useWorlds.ts
-import { useCallback as useCallback4, useEffect as useEffect10 } from "react";
+import { useCallback as useCallback4, useEffect as useEffect12 } from "react";
 function useWorlds() {
   const worlds = useStore((s) => s.worlds.worlds);
   const loading = useStore((s) => s.worlds.loading);
@@ -44788,7 +46646,7 @@ function useWorlds() {
 }
 
 // src/tui/screens/Settings.tsx
-import { jsx as jsx15, jsxs as jsxs14 } from "react/jsx-runtime";
+import { jsx as jsx20, jsxs as jsxs19 } from "react/jsx-runtime";
 var SECTION_LABELS = {
   server: "Server",
   modifiers: "Difficulty Modifiers",
@@ -44868,10 +46726,10 @@ var Settings = () => {
   const editingField = useStore((s) => s.ui.editingField);
   const setEditingField = useStore((s) => s.actions.setEditingField);
   const addLog = useStore((s) => s.actions.addLog);
-  const [selectedIndex, setSelectedIndex] = useState10(0);
-  const [localValue, setLocalValue] = useState10("");
-  const [scrollOffset, setScrollOffset] = useState10(0);
-  const [expandedSections, setExpandedSections] = useState10(
+  const [selectedIndex, setSelectedIndex] = useState15(0);
+  const [localValue, setLocalValue] = useState15("");
+  const [scrollOffset, setScrollOffset] = useState15(0);
+  const [expandedSections, setExpandedSections] = useState15(
     () => /* @__PURE__ */ new Set(["server"])
   );
   const MAX_VISIBLE_ROWS = 15;
@@ -45235,7 +47093,7 @@ var Settings = () => {
   const cancelEdit = useCallback5(() => {
     setEditingField(null);
   }, [setEditingField]);
-  useInput8(
+  useInput13(
     (input, key) => {
       if (isEditing) return;
       if (key.upArrow || input === "k") {
@@ -45291,14 +47149,14 @@ var Settings = () => {
       const itemCount = settings.filter(
         (s) => s.section === item.section
       ).length;
-      return /* @__PURE__ */ jsxs14(Box15, { flexShrink: 0, minHeight: 1, children: [
-        /* @__PURE__ */ jsx15(Text15, { color: isSelected ? theme.primary : void 0, children: isSelected ? "\u25B6 " : "  " }),
-        /* @__PURE__ */ jsxs14(Text15, { bold: true, color: isSelected ? theme.primary : theme.secondary, children: [
+      return /* @__PURE__ */ jsxs19(Box20, { flexShrink: 0, minHeight: 1, children: [
+        /* @__PURE__ */ jsx20(Text20, { color: isSelected ? theme.primary : void 0, children: isSelected ? "\u25B6 " : "  " }),
+        /* @__PURE__ */ jsxs19(Text20, { bold: true, color: isSelected ? theme.primary : theme.secondary, children: [
           isExpanded ? "\u25BC" : "\u25B6",
           " ",
           item.label
         ] }),
-        /* @__PURE__ */ jsxs14(Text15, { dimColor: true, children: [
+        /* @__PURE__ */ jsxs19(Text20, { dimColor: true, children: [
           " (",
           itemCount,
           ")"
@@ -45312,13 +47170,13 @@ var Settings = () => {
       switch (setting.type) {
         case "text":
         case "password":
-          return /* @__PURE__ */ jsxs14(Box15, { flexShrink: 0, minHeight: 1, children: [
-            /* @__PURE__ */ jsxs14(Text15, { color: theme.primary, children: [
+          return /* @__PURE__ */ jsxs19(Box20, { flexShrink: 0, minHeight: 1, children: [
+            /* @__PURE__ */ jsxs19(Text20, { color: theme.primary, children: [
               " \u25B6 ",
               setting.label,
               ": "
             ] }),
-            /* @__PURE__ */ jsx15(
+            /* @__PURE__ */ jsx20(
               TextInput,
               {
                 value: localValue,
@@ -45331,13 +47189,13 @@ var Settings = () => {
             )
           ] }, setting.key);
         case "number":
-          return /* @__PURE__ */ jsxs14(Box15, { flexShrink: 0, minHeight: 1, children: [
-            /* @__PURE__ */ jsxs14(Text15, { color: theme.primary, children: [
+          return /* @__PURE__ */ jsxs19(Box20, { flexShrink: 0, minHeight: 1, children: [
+            /* @__PURE__ */ jsxs19(Text20, { color: theme.primary, children: [
               " \u25B6 ",
               setting.label,
               ": "
             ] }),
-            /* @__PURE__ */ jsx15(
+            /* @__PURE__ */ jsx20(
               NumberInput,
               {
                 value: localValue,
@@ -45353,13 +47211,13 @@ var Settings = () => {
             )
           ] }, setting.key);
         case "select":
-          return /* @__PURE__ */ jsxs14(Box15, { flexDirection: "column", flexShrink: 0, children: [
-            /* @__PURE__ */ jsx15(Box15, { flexShrink: 0, children: /* @__PURE__ */ jsxs14(Text15, { color: theme.primary, children: [
+          return /* @__PURE__ */ jsxs19(Box20, { flexDirection: "column", flexShrink: 0, children: [
+            /* @__PURE__ */ jsx20(Box20, { flexShrink: 0, children: /* @__PURE__ */ jsxs19(Text20, { color: theme.primary, children: [
               " \u25B6 ",
               setting.label,
               ": "
             ] }) }),
-            /* @__PURE__ */ jsx15(Box15, { marginLeft: 4, children: /* @__PURE__ */ jsx15(
+            /* @__PURE__ */ jsx20(Box20, { marginLeft: 4, children: /* @__PURE__ */ jsx20(
               SelectInput,
               {
                 options: setting.options ?? [],
@@ -45382,15 +47240,15 @@ var Settings = () => {
       }
     }
     const displayValue = setting.type === "toggle" ? value ? "Yes" : "No" : setting.type === "password" ? value ? "********" : "(none)" : setting.type === "select" ? setting.options?.find((o) => o.value === value)?.label ?? value : `${value}${setting.suffix ?? ""}`;
-    return /* @__PURE__ */ jsxs14(Box15, { flexShrink: 0, minHeight: 1, children: [
-      /* @__PURE__ */ jsx15(Text15, { color: isSelected ? theme.primary : void 0, children: isSelected ? "  \u25B6 " : "    " }),
-      /* @__PURE__ */ jsxs14(Text15, { bold: isSelected, color: isSelected ? theme.primary : void 0, children: [
+    return /* @__PURE__ */ jsxs19(Box20, { flexShrink: 0, minHeight: 1, children: [
+      /* @__PURE__ */ jsx20(Text20, { color: isSelected ? theme.primary : void 0, children: isSelected ? "  \u25B6 " : "    " }),
+      /* @__PURE__ */ jsxs19(Text20, { bold: isSelected, color: isSelected ? theme.primary : void 0, children: [
         setting.label,
         ":"
       ] }),
-      /* @__PURE__ */ jsx15(Text15, { children: " " }),
-      /* @__PURE__ */ jsx15(
-        Text15,
+      /* @__PURE__ */ jsx20(Text20, { children: " " }),
+      /* @__PURE__ */ jsx20(
+        Text20,
         {
           color: setting.type === "toggle" ? value ? theme.success : theme.error : theme.secondary,
           children: displayValue
@@ -45398,36 +47256,36 @@ var Settings = () => {
       )
     ] }, setting.key);
   };
-  return /* @__PURE__ */ jsxs14(Box15, { flexDirection: "column", flexGrow: 1, padding: 1, overflow: "hidden", children: [
-    /* @__PURE__ */ jsx15(Box15, { marginBottom: 1, flexShrink: 0, minHeight: 1, children: /* @__PURE__ */ jsx15(Text15, { bold: true, color: theme.primary, children: "\u2500 Settings \u2500" }) }),
-    /* @__PURE__ */ jsx15(Box15, { marginBottom: 1, flexShrink: 0, minHeight: 1, children: /* @__PURE__ */ jsx15(Text15, { dimColor: true, children: isEditing ? "Enter to save, Esc to cancel" : "\u2191/\u2193 navigate \u2022 Enter expand/edit \u2022 Tab collapse all" }) }),
-    hasMoreAbove && /* @__PURE__ */ jsx15(Box15, { flexShrink: 0, minHeight: 1, children: /* @__PURE__ */ jsxs14(Text15, { dimColor: true, children: [
+  return /* @__PURE__ */ jsxs19(Box20, { flexDirection: "column", flexGrow: 1, padding: 1, overflow: "hidden", children: [
+    /* @__PURE__ */ jsx20(Box20, { marginBottom: 1, flexShrink: 0, minHeight: 1, children: /* @__PURE__ */ jsx20(Text20, { bold: true, color: theme.primary, children: "\u2500 Settings \u2500" }) }),
+    /* @__PURE__ */ jsx20(Box20, { marginBottom: 1, flexShrink: 0, minHeight: 1, children: /* @__PURE__ */ jsx20(Text20, { dimColor: true, children: isEditing ? "Enter to save, Esc to cancel" : "\u2191/\u2193 navigate \u2022 Enter expand/edit \u2022 Tab collapse all" }) }),
+    hasMoreAbove && /* @__PURE__ */ jsx20(Box20, { flexShrink: 0, minHeight: 1, children: /* @__PURE__ */ jsxs19(Text20, { dimColor: true, children: [
       " \u2191 ",
       scrollOffset,
       " more above"
     ] }) }),
-    /* @__PURE__ */ jsx15(Box15, { flexDirection: "column", flexGrow: 1, overflow: "hidden", children: visibleItems.map((item, visibleIdx) => {
+    /* @__PURE__ */ jsx20(Box20, { flexDirection: "column", flexGrow: 1, overflow: "hidden", children: visibleItems.map((item, visibleIdx) => {
       const globalIndex = scrollOffset + visibleIdx;
       return renderNavItem(item, globalIndex);
     }) }),
-    hasMoreBelow && /* @__PURE__ */ jsx15(Box15, { flexShrink: 0, minHeight: 1, children: /* @__PURE__ */ jsxs14(Text15, { dimColor: true, children: [
+    hasMoreBelow && /* @__PURE__ */ jsx20(Box20, { flexShrink: 0, minHeight: 1, children: /* @__PURE__ */ jsxs19(Text20, { dimColor: true, children: [
       "  ",
       "\u2193 ",
       navItems.length - scrollOffset - MAX_VISIBLE_ROWS,
       " more below"
     ] }) }),
-    rcon.enabled && /* @__PURE__ */ jsxs14(Box15, { marginTop: 1, flexShrink: 0, minHeight: 1, children: [
-      /* @__PURE__ */ jsx15(Text15, { dimColor: true, children: "RCON Status: " }),
-      /* @__PURE__ */ jsx15(Text15, { color: rcon.connected ? theme.success : theme.error, children: rcon.connected ? "Connected" : "Disconnected" })
+    rcon.enabled && /* @__PURE__ */ jsxs19(Box20, { marginTop: 1, flexShrink: 0, minHeight: 1, children: [
+      /* @__PURE__ */ jsx20(Text20, { dimColor: true, children: "RCON Status: " }),
+      /* @__PURE__ */ jsx20(Text20, { color: rcon.connected ? theme.success : theme.error, children: rcon.connected ? "Connected" : "Disconnected" })
     ] }),
-    /* @__PURE__ */ jsx15(Box15, { marginTop: 1, flexShrink: 0, minHeight: 1, children: /* @__PURE__ */ jsx15(Text15, { dimColor: true, children: "Note: Restart server for changes to take effect" }) })
+    /* @__PURE__ */ jsx20(Box20, { marginTop: 1, flexShrink: 0, minHeight: 1, children: /* @__PURE__ */ jsx20(Text20, { dimColor: true, children: "Note: Restart server for changes to take effect" }) })
   ] });
 };
 
 // src/tui/screens/Worlds.tsx
-import { Box as Box16, Text as Text16, useInput as useInput9 } from "ink";
-import { useCallback as useCallback6, useEffect as useEffect11, useState as useState11 } from "react";
-import { Fragment, jsx as jsx16, jsxs as jsxs15 } from "react/jsx-runtime";
+import { Box as Box21, Text as Text21, useInput as useInput14 } from "ink";
+import { useCallback as useCallback6, useEffect as useEffect13, useState as useState16 } from "react";
+import { Fragment as Fragment5, jsx as jsx21, jsxs as jsxs20 } from "react/jsx-runtime";
 function formatBytes2(bytes) {
   if (bytes === 0) return "0 B";
   const k = 1024;
@@ -45480,16 +47338,16 @@ var Worlds = () => {
   const serverStatus = useStore((s) => s.server.status);
   const worldGenerating = useStore((s) => s.server.worldGenerating);
   const setEditingField = useStore((s) => s.actions.setEditingField);
-  const [mode, setModeInternal] = useState11("list");
-  const [inputPath, setInputPath] = useState11("");
-  const [newWorldName, setNewWorldName] = useState11("");
-  const [newWorldSeed, setNewWorldSeed] = useState11("");
-  const [createStep, setCreateStep] = useState11("name");
-  const [loading, setLoading] = useState11(false);
-  const [operationStatus, setOperationStatus] = useState11("");
-  const [pendingConfigSelected, setPendingConfigSelected] = useState11(false);
-  const [prevServerStatus, setPrevServerStatus] = useState11(serverStatus);
-  const [prevWorldGenerating, setPrevWorldGenerating] = useState11(worldGenerating);
+  const [mode, setModeInternal] = useState16("list");
+  const [inputPath, setInputPath] = useState16("");
+  const [newWorldName, setNewWorldName] = useState16("");
+  const [newWorldSeed, setNewWorldSeed] = useState16("");
+  const [createStep, setCreateStep] = useState16("name");
+  const [loading, setLoading] = useState16(false);
+  const [operationStatus, setOperationStatus] = useState16("");
+  const [pendingConfigSelected, setPendingConfigSelected] = useState16(false);
+  const [prevServerStatus, setPrevServerStatus] = useState16(serverStatus);
+  const [prevWorldGenerating, setPrevWorldGenerating] = useState16(worldGenerating);
   const hasPendingConfig = config.world && !worlds.some((w) => w.name === config.world);
   const otherPendingWorlds = pendingWorldNames.filter(
     (name) => name !== config.world && !worlds.some((w) => w.name === name)
@@ -45502,10 +47360,10 @@ var Worlds = () => {
     },
     [setEditingField]
   );
-  useEffect11(() => {
+  useEffect13(() => {
     refresh();
   }, [refresh]);
-  useEffect11(() => {
+  useEffect13(() => {
     if (prevServerStatus !== "online" && serverStatus === "online") {
       const timer = setTimeout(() => {
         refresh();
@@ -45515,14 +47373,14 @@ var Worlds = () => {
     }
     setPrevServerStatus(serverStatus);
   }, [serverStatus, prevServerStatus, refresh, addLog]);
-  useEffect11(() => {
+  useEffect13(() => {
     if (prevWorldGenerating && !worldGenerating) {
       refresh();
       addLog("info", "Refreshed worlds list after world generation completed");
     }
     setPrevWorldGenerating(worldGenerating);
   }, [worldGenerating, prevWorldGenerating, refresh, addLog]);
-  useEffect11(() => {
+  useEffect13(() => {
     if (!hasPendingConfig && pendingConfigSelected) {
       setPendingConfigSelected(false);
     }
@@ -45669,7 +47527,7 @@ var Worlds = () => {
     },
     [closeModal, getSelectedWorld, config.world, deleteWorld2, refresh, addLog]
   );
-  useInput9(
+  useInput14(
     (input, key) => {
       if (modalOpen || loading) return;
       if (key.upArrow || input === "k") {
@@ -45722,7 +47580,7 @@ var Worlds = () => {
         const world = getSelectedWorld();
         if (world && world.name !== config.world) {
           openModal(
-            /* @__PURE__ */ jsx16(
+            /* @__PURE__ */ jsx21(
               DeleteWorldModal,
               {
                 worldName: world.name,
@@ -45787,27 +47645,27 @@ var Worlds = () => {
     handleBackup
   ]);
   if (worldsLoading && worlds.length === 0) {
-    return /* @__PURE__ */ jsxs15(Box16, { flexDirection: "column", flexGrow: 1, padding: 1, children: [
-      /* @__PURE__ */ jsx16(Box16, { marginBottom: 1, children: /* @__PURE__ */ jsx16(Text16, { bold: true, color: theme.primary, children: "\u2500 Worlds \u2500" }) }),
-      /* @__PURE__ */ jsx16(Spinner, { label: "Loading worlds..." })
+    return /* @__PURE__ */ jsxs20(Box21, { flexDirection: "column", flexGrow: 1, padding: 1, children: [
+      /* @__PURE__ */ jsx21(Box21, { marginBottom: 1, children: /* @__PURE__ */ jsx21(Text21, { bold: true, color: theme.primary, children: "\u2500 Worlds \u2500" }) }),
+      /* @__PURE__ */ jsx21(Spinner, { label: "Loading worlds..." })
     ] });
   }
   if (error2 && worlds.length === 0) {
-    return /* @__PURE__ */ jsxs15(Box16, { flexDirection: "column", flexGrow: 1, padding: 1, children: [
-      /* @__PURE__ */ jsx16(Box16, { marginBottom: 1, children: /* @__PURE__ */ jsx16(Text16, { bold: true, color: theme.primary, children: "\u2500 Worlds \u2500" }) }),
-      /* @__PURE__ */ jsxs15(Text16, { color: theme.error, children: [
+    return /* @__PURE__ */ jsxs20(Box21, { flexDirection: "column", flexGrow: 1, padding: 1, children: [
+      /* @__PURE__ */ jsx21(Box21, { marginBottom: 1, children: /* @__PURE__ */ jsx21(Text21, { bold: true, color: theme.primary, children: "\u2500 Worlds \u2500" }) }),
+      /* @__PURE__ */ jsxs20(Text21, { color: theme.error, children: [
         "Error: ",
         error2
       ] }),
-      /* @__PURE__ */ jsx16(Box16, { marginTop: 1, children: /* @__PURE__ */ jsx16(Text16, { dimColor: true, children: "Press R to retry" }) })
+      /* @__PURE__ */ jsx21(Box21, { marginTop: 1, children: /* @__PURE__ */ jsx21(Text21, { dimColor: true, children: "Press R to retry" }) })
     ] });
   }
   if (mode === "create") {
-    return /* @__PURE__ */ jsxs15(Box16, { flexDirection: "column", flexGrow: 1, padding: 1, children: [
-      /* @__PURE__ */ jsx16(Box16, { marginBottom: 1, children: /* @__PURE__ */ jsx16(Text16, { bold: true, color: theme.primary, children: "\u2500 Create New World \u2500" }) }),
-      loading ? /* @__PURE__ */ jsx16(Spinner, { label: operationStatus }) : createStep === "name" ? /* @__PURE__ */ jsxs15(Fragment, { children: [
-        /* @__PURE__ */ jsx16(Box16, { marginBottom: 1, children: /* @__PURE__ */ jsx16(Text16, { children: "Enter a name for your new world:" }) }),
-        /* @__PURE__ */ jsx16(Box16, { children: /* @__PURE__ */ jsx16(
+    return /* @__PURE__ */ jsxs20(Box21, { flexDirection: "column", flexGrow: 1, padding: 1, children: [
+      /* @__PURE__ */ jsx21(Box21, { marginBottom: 1, children: /* @__PURE__ */ jsx21(Text21, { bold: true, color: theme.primary, children: "\u2500 Create New World \u2500" }) }),
+      loading ? /* @__PURE__ */ jsx21(Spinner, { label: operationStatus }) : createStep === "name" ? /* @__PURE__ */ jsxs20(Fragment5, { children: [
+        /* @__PURE__ */ jsx21(Box21, { marginBottom: 1, children: /* @__PURE__ */ jsx21(Text21, { children: "Enter a name for your new world:" }) }),
+        /* @__PURE__ */ jsx21(Box21, { children: /* @__PURE__ */ jsx21(
           TextInput,
           {
             value: newWorldName,
@@ -45818,14 +47676,14 @@ var Worlds = () => {
             focus: true
           }
         ) }),
-        /* @__PURE__ */ jsx16(Box16, { marginTop: 1, children: /* @__PURE__ */ jsx16(Text16, { dimColor: true, children: "Enter to continue, Esc to cancel" }) })
-      ] }) : /* @__PURE__ */ jsxs15(Fragment, { children: [
-        /* @__PURE__ */ jsxs15(Box16, { marginBottom: 1, children: [
-          /* @__PURE__ */ jsx16(Text16, { children: "World: " }),
-          /* @__PURE__ */ jsx16(Text16, { color: theme.primary, bold: true, children: newWorldName })
+        /* @__PURE__ */ jsx21(Box21, { marginTop: 1, children: /* @__PURE__ */ jsx21(Text21, { dimColor: true, children: "Enter to continue, Esc to cancel" }) })
+      ] }) : /* @__PURE__ */ jsxs20(Fragment5, { children: [
+        /* @__PURE__ */ jsxs20(Box21, { marginBottom: 1, children: [
+          /* @__PURE__ */ jsx21(Text21, { children: "World: " }),
+          /* @__PURE__ */ jsx21(Text21, { color: theme.primary, bold: true, children: newWorldName })
         ] }),
-        /* @__PURE__ */ jsx16(Box16, { marginBottom: 1, children: /* @__PURE__ */ jsx16(Text16, { children: "Enter a seed (optional, leave empty for random):" }) }),
-        /* @__PURE__ */ jsx16(Box16, { children: /* @__PURE__ */ jsx16(
+        /* @__PURE__ */ jsx21(Box21, { marginBottom: 1, children: /* @__PURE__ */ jsx21(Text21, { children: "Enter a seed (optional, leave empty for random):" }) }),
+        /* @__PURE__ */ jsx21(Box21, { children: /* @__PURE__ */ jsx21(
           TextInput,
           {
             value: newWorldSeed,
@@ -45836,26 +47694,26 @@ var Worlds = () => {
             focus: true
           }
         ) }),
-        /* @__PURE__ */ jsx16(Box16, { marginTop: 1, children: /* @__PURE__ */ jsx16(Text16, { dimColor: true, children: "Enter to create world, Esc to cancel" }) }),
-        /* @__PURE__ */ jsx16(Box16, { marginTop: 1, children: /* @__PURE__ */ jsx16(Text16, { color: theme.warning, children: "Note: Start the server to generate the world files" }) })
+        /* @__PURE__ */ jsx21(Box21, { marginTop: 1, children: /* @__PURE__ */ jsx21(Text21, { dimColor: true, children: "Enter to create world, Esc to cancel" }) }),
+        /* @__PURE__ */ jsx21(Box21, { marginTop: 1, children: /* @__PURE__ */ jsx21(Text21, { color: theme.warning, children: "Note: Start the server to generate the world files" }) })
       ] })
     ] });
   }
   if (mode !== "list") {
     const modeTitle = mode === "import" ? "Import World" : mode === "export" ? "Export World" : "Backup World";
     const modeHint = mode === "import" ? "Enter path to world folder or .db file" : mode === "export" ? `Export "${selectedWorld}" to path` : `Backup "${selectedWorld}" to path`;
-    return /* @__PURE__ */ jsxs15(Box16, { flexDirection: "column", flexGrow: 1, padding: 1, children: [
-      /* @__PURE__ */ jsx16(Box16, { marginBottom: 1, children: /* @__PURE__ */ jsxs15(Text16, { bold: true, color: theme.primary, children: [
+    return /* @__PURE__ */ jsxs20(Box21, { flexDirection: "column", flexGrow: 1, padding: 1, children: [
+      /* @__PURE__ */ jsx21(Box21, { marginBottom: 1, children: /* @__PURE__ */ jsxs20(Text21, { bold: true, color: theme.primary, children: [
         "\u2500 ",
         modeTitle,
         " \u2500"
       ] }) }),
-      loading ? /* @__PURE__ */ jsx16(Spinner, { label: operationStatus }) : /* @__PURE__ */ jsxs15(Fragment, { children: [
-        /* @__PURE__ */ jsx16(Box16, { marginBottom: 1, children: /* @__PURE__ */ jsxs15(Text16, { children: [
+      loading ? /* @__PURE__ */ jsx21(Spinner, { label: operationStatus }) : /* @__PURE__ */ jsxs20(Fragment5, { children: [
+        /* @__PURE__ */ jsx21(Box21, { marginBottom: 1, children: /* @__PURE__ */ jsxs20(Text21, { children: [
           modeHint,
           ":"
         ] }) }),
-        /* @__PURE__ */ jsx16(Box16, { children: /* @__PURE__ */ jsx16(
+        /* @__PURE__ */ jsx21(Box21, { children: /* @__PURE__ */ jsx21(
           TextInput,
           {
             value: inputPath,
@@ -45866,19 +47724,19 @@ var Worlds = () => {
             focus: true
           }
         ) }),
-        /* @__PURE__ */ jsx16(Box16, { marginTop: 1, children: /* @__PURE__ */ jsx16(Text16, { dimColor: true, children: "Enter to confirm, Esc to cancel" }) })
+        /* @__PURE__ */ jsx21(Box21, { marginTop: 1, children: /* @__PURE__ */ jsx21(Text21, { dimColor: true, children: "Enter to confirm, Esc to cancel" }) })
       ] })
     ] });
   }
-  return /* @__PURE__ */ jsxs15(Box16, { flexDirection: "column", flexGrow: 1, padding: 1, overflow: "hidden", children: [
-    /* @__PURE__ */ jsxs15(Box16, { marginBottom: 1, children: [
-      /* @__PURE__ */ jsx16(Text16, { bold: true, color: theme.primary, children: "\u2500 Worlds \u2500" }),
-      worldsLoading && /* @__PURE__ */ jsx16(Spinner, {})
+  return /* @__PURE__ */ jsxs20(Box21, { flexDirection: "column", flexGrow: 1, padding: 1, overflow: "hidden", children: [
+    /* @__PURE__ */ jsxs20(Box21, { marginBottom: 1, children: [
+      /* @__PURE__ */ jsx21(Text21, { bold: true, color: theme.primary, children: "\u2500 Worlds \u2500" }),
+      worldsLoading && /* @__PURE__ */ jsx21(Spinner, {})
     ] }),
-    /* @__PURE__ */ jsx16(Box16, { marginBottom: 1, children: /* @__PURE__ */ jsx16(Text16, { dimColor: true, children: "\u2191/\u2193 Navigate | Enter Set Active | N New | I Import | E Export | B Backup | D Delete | R Refresh" }) }),
-    /* @__PURE__ */ jsxs15(Box16, { flexDirection: "column", overflow: "hidden", children: [
-      hasPendingConfig && /* @__PURE__ */ jsxs15(
-        Box16,
+    /* @__PURE__ */ jsx21(Box21, { marginBottom: 1, children: /* @__PURE__ */ jsx21(Text21, { dimColor: true, children: "\u2191/\u2193 Navigate | Enter Set Active | N New | I Import | E Export | B Backup | D Delete | R Refresh" }) }),
+    /* @__PURE__ */ jsxs20(Box21, { flexDirection: "column", overflow: "hidden", children: [
+      hasPendingConfig && /* @__PURE__ */ jsxs20(
+        Box21,
         {
           flexDirection: "column",
           flexShrink: 0,
@@ -45887,33 +47745,33 @@ var Worlds = () => {
           paddingX: pendingConfigSelected || worlds.length === 0 ? 1 : 0,
           marginBottom: 1,
           children: [
-            /* @__PURE__ */ jsxs15(Box16, { flexShrink: 0, children: [
-              /* @__PURE__ */ jsx16(
-                Text16,
+            /* @__PURE__ */ jsxs20(Box21, { flexShrink: 0, children: [
+              /* @__PURE__ */ jsx21(
+                Text21,
                 {
                   color: pendingConfigSelected ? theme.primary : void 0,
                   bold: true,
                   children: config.world
                 }
               ),
-              /* @__PURE__ */ jsx16(Text16, { color: theme.success, children: " (Active)" }),
-              worldGenerating ? /* @__PURE__ */ jsxs15(Box16, { marginLeft: 1, children: [
-                /* @__PURE__ */ jsx16(Spinner, {}),
-                /* @__PURE__ */ jsx16(Text16, { color: theme.warning, children: " Generating..." })
-              ] }) : serverStatus === "starting" ? /* @__PURE__ */ jsxs15(Box16, { marginLeft: 1, children: [
-                /* @__PURE__ */ jsx16(Spinner, {}),
-                /* @__PURE__ */ jsx16(Text16, { color: theme.info, children: " Server starting..." })
-              ] }) : /* @__PURE__ */ jsx16(Text16, { color: theme.warning, children: " - Not generated" })
+              /* @__PURE__ */ jsx21(Text21, { color: theme.success, children: " (Active)" }),
+              worldGenerating ? /* @__PURE__ */ jsxs20(Box21, { marginLeft: 1, children: [
+                /* @__PURE__ */ jsx21(Spinner, {}),
+                /* @__PURE__ */ jsx21(Text21, { color: theme.warning, children: " Generating..." })
+              ] }) : serverStatus === "starting" ? /* @__PURE__ */ jsxs20(Box21, { marginLeft: 1, children: [
+                /* @__PURE__ */ jsx21(Spinner, {}),
+                /* @__PURE__ */ jsx21(Text21, { color: theme.info, children: " Server starting..." })
+              ] }) : /* @__PURE__ */ jsx21(Text21, { color: theme.warning, children: " - Not generated" })
             ] }),
-            /* @__PURE__ */ jsx16(Box16, { marginLeft: 2, flexShrink: 0, children: worldGenerating ? /* @__PURE__ */ jsx16(Text16, { dimColor: true, children: "New world is being generated (this may take ~1 minute)" }) : /* @__PURE__ */ jsx16(Text16, { dimColor: true, children: "Start the server to generate this world" }) })
+            /* @__PURE__ */ jsx21(Box21, { marginLeft: 2, flexShrink: 0, children: worldGenerating ? /* @__PURE__ */ jsx21(Text21, { dimColor: true, children: "New world is being generated (this may take ~1 minute)" }) : /* @__PURE__ */ jsx21(Text21, { dimColor: true, children: "Start the server to generate this world" }) })
           ]
         }
       ),
-      worlds.length === 0 && !config.world ? /* @__PURE__ */ jsx16(Text16, { dimColor: true, children: "No worlds found. Press N to create one." }) : worlds.map((world) => {
+      worlds.length === 0 && !config.world ? /* @__PURE__ */ jsx21(Text21, { dimColor: true, children: "No worlds found. Press N to create one." }) : worlds.map((world) => {
         const isSelected = world.name === selectedWorld;
         const isActive = world.name === config.world;
-        return /* @__PURE__ */ jsxs15(
-          Box16,
+        return /* @__PURE__ */ jsxs20(
+          Box21,
           {
             flexDirection: "column",
             flexShrink: 0,
@@ -45922,11 +47780,11 @@ var Worlds = () => {
             paddingX: isSelected ? 1 : 0,
             marginBottom: 1,
             children: [
-              /* @__PURE__ */ jsxs15(Box16, { flexShrink: 0, children: [
-                /* @__PURE__ */ jsx16(Text16, { color: isSelected ? theme.primary : void 0, bold: true, children: world.name }),
-                isActive && /* @__PURE__ */ jsx16(Text16, { color: theme.success, children: " (Active)" }),
-                world.pendingSave && /* @__PURE__ */ jsx16(Text16, { color: theme.warning, children: " - Pending Save" }),
-                world.backups && world.backups.length > 0 && /* @__PURE__ */ jsxs15(Text16, { color: theme.info, children: [
+              /* @__PURE__ */ jsxs20(Box21, { flexShrink: 0, children: [
+                /* @__PURE__ */ jsx21(Text21, { color: isSelected ? theme.primary : void 0, bold: true, children: world.name }),
+                isActive && /* @__PURE__ */ jsx21(Text21, { color: theme.success, children: " (Active)" }),
+                world.pendingSave && /* @__PURE__ */ jsx21(Text21, { color: theme.warning, children: " - Pending Save" }),
+                world.backups && world.backups.length > 0 && /* @__PURE__ */ jsxs20(Text21, { color: theme.info, children: [
                   " ",
                   "[",
                   world.backups.length,
@@ -45935,27 +47793,27 @@ var Worlds = () => {
                   "]"
                 ] })
               ] }),
-              /* @__PURE__ */ jsx16(Box16, { marginLeft: 2, flexShrink: 0, children: world.pendingSave ? /* @__PURE__ */ jsx16(Text16, { dimColor: true, children: "World generated but not yet saved to disk" }) : /* @__PURE__ */ jsxs15(Fragment, { children: [
-                /* @__PURE__ */ jsxs15(Text16, { dimColor: true, children: [
+              /* @__PURE__ */ jsx21(Box21, { marginLeft: 2, flexShrink: 0, children: world.pendingSave ? /* @__PURE__ */ jsx21(Text21, { dimColor: true, children: "World generated but not yet saved to disk" }) : /* @__PURE__ */ jsxs20(Fragment5, { children: [
+                /* @__PURE__ */ jsxs20(Text21, { dimColor: true, children: [
                   "Size: ",
                   formatBytes2(world.size)
                 ] }),
-                /* @__PURE__ */ jsx16(Text16, { dimColor: true, children: " | " }),
-                /* @__PURE__ */ jsx16(Text16, { dimColor: true, children: getSourceLabel(world.source) })
+                /* @__PURE__ */ jsx21(Text21, { dimColor: true, children: " | " }),
+                /* @__PURE__ */ jsx21(Text21, { dimColor: true, children: getSourceLabel(world.source) })
               ] }) }),
-              !world.pendingSave && /* @__PURE__ */ jsx16(Box16, { marginLeft: 2, flexShrink: 0, children: /* @__PURE__ */ jsxs15(Text16, { dimColor: true, children: [
+              !world.pendingSave && /* @__PURE__ */ jsx21(Box21, { marginLeft: 2, flexShrink: 0, children: /* @__PURE__ */ jsxs20(Text21, { dimColor: true, children: [
                 "Modified: ",
                 formatDate(world.modified)
               ] }) }),
-              isSelected && world.backups && world.backups.length > 0 && /* @__PURE__ */ jsxs15(Box16, { marginLeft: 2, flexDirection: "column", flexShrink: 0, children: [
-                /* @__PURE__ */ jsx16(Text16, { dimColor: true, children: "Backups:" }),
-                world.backups.slice(0, 3).map((backup) => /* @__PURE__ */ jsx16(Box16, { marginLeft: 2, children: /* @__PURE__ */ jsxs15(Text16, { dimColor: true, children: [
+              isSelected && world.backups && world.backups.length > 0 && /* @__PURE__ */ jsxs20(Box21, { marginLeft: 2, flexDirection: "column", flexShrink: 0, children: [
+                /* @__PURE__ */ jsx21(Text21, { dimColor: true, children: "Backups:" }),
+                world.backups.slice(0, 3).map((backup) => /* @__PURE__ */ jsx21(Box21, { marginLeft: 2, children: /* @__PURE__ */ jsxs20(Text21, { dimColor: true, children: [
                   "\u2022",
                   " ",
                   formatBackupTimestamp(backup.backupTimestamp ?? ""),
                   backup.pendingSave ? " (pending)" : ` (${formatBytes2(backup.size)})`
                 ] }) }, backup.name)),
-                world.backups.length > 3 && /* @__PURE__ */ jsx16(Box16, { marginLeft: 2, children: /* @__PURE__ */ jsxs15(Text16, { dimColor: true, children: [
+                world.backups.length > 3 && /* @__PURE__ */ jsx21(Box21, { marginLeft: 2, children: /* @__PURE__ */ jsxs20(Text21, { dimColor: true, children: [
                   "... and ",
                   world.backups.length - 3,
                   " more"
@@ -45966,30 +47824,30 @@ var Worlds = () => {
           world.name
         );
       }),
-      otherPendingWorlds.map((name) => /* @__PURE__ */ jsxs15(
-        Box16,
+      otherPendingWorlds.map((name) => /* @__PURE__ */ jsxs20(
+        Box21,
         {
           flexDirection: "column",
           flexShrink: 0,
           marginBottom: 1,
           children: [
-            /* @__PURE__ */ jsxs15(Box16, { flexShrink: 0, children: [
-              /* @__PURE__ */ jsx16(Text16, { dimColor: true, children: name }),
-              /* @__PURE__ */ jsx16(Text16, { color: theme.warning, children: " - Not generated" })
+            /* @__PURE__ */ jsxs20(Box21, { flexShrink: 0, children: [
+              /* @__PURE__ */ jsx21(Text21, { dimColor: true, children: name }),
+              /* @__PURE__ */ jsx21(Text21, { color: theme.warning, children: " - Not generated" })
             ] }),
-            /* @__PURE__ */ jsx16(Box16, { marginLeft: 2, flexShrink: 0, children: /* @__PURE__ */ jsx16(Text16, { dimColor: true, children: "Set as active and start the server to generate" }) })
+            /* @__PURE__ */ jsx21(Box21, { marginLeft: 2, flexShrink: 0, children: /* @__PURE__ */ jsx21(Text21, { dimColor: true, children: "Set as active and start the server to generate" }) })
           ]
         },
         `pending-${name}`
       ))
     ] }),
-    operationStatus && /* @__PURE__ */ jsx16(Box16, { marginTop: 1, children: /* @__PURE__ */ jsx16(Text16, { dimColor: true, children: operationStatus }) }),
-    serverStatus !== "offline" && /* @__PURE__ */ jsx16(Box16, { marginTop: 1, children: /* @__PURE__ */ jsx16(Text16, { color: theme.warning, children: "Stop the server to change or delete worlds" }) })
+    operationStatus && /* @__PURE__ */ jsx21(Box21, { marginTop: 1, children: /* @__PURE__ */ jsx21(Text21, { dimColor: true, children: operationStatus }) }),
+    serverStatus !== "offline" && /* @__PURE__ */ jsx21(Box21, { marginTop: 1, children: /* @__PURE__ */ jsx21(Text21, { color: theme.warning, children: "Stop the server to change or delete worlds" }) })
   ] });
 };
 
 // src/tui/App.tsx
-import { jsx as jsx17, jsxs as jsxs16 } from "react/jsx-runtime";
+import { jsx as jsx22, jsxs as jsxs21 } from "react/jsx-runtime";
 var screens = {
   dashboard: Dashboard,
   settings: Settings,
@@ -46006,11 +47864,11 @@ var App = () => {
   const openModal = useStore((s) => s.actions.openModal);
   const addLog = useStore((s) => s.actions.addLog);
   useConfigSync();
-  useEffect12(() => {
+  useEffect14(() => {
     addLog("info", "TUI started");
     addLog("info", "Press 1-4 to navigate, ? for help, Q to quit");
   }, [addLog]);
-  useInput10((input, key) => {
+  useInput15((input, key) => {
     if (modalOpen || editingField) return;
     if (input === "q" || input === "Q" || key.ctrl && input === "c") {
       addLog("info", "Shutting down...");
@@ -46019,7 +47877,7 @@ var App = () => {
       return;
     }
     if (input === "?") {
-      openModal(/* @__PURE__ */ jsx17(HelpOverlay, {}));
+      openModal(/* @__PURE__ */ jsx22(HelpOverlay, {}));
       return;
     }
     if (input === "1") setScreen("dashboard");
@@ -46028,25 +47886,25 @@ var App = () => {
     if (input === "4") setScreen("console");
   });
   const ScreenComponent = screens[activeScreen] ?? Dashboard;
-  return /* @__PURE__ */ jsxs16(Box17, { flexDirection: "column", height: "100%", width: "100%", children: [
-    /* @__PURE__ */ jsx17(Header, {}),
-    /* @__PURE__ */ jsxs16(Box17, { flexGrow: 1, flexDirection: "row", height: "100%", children: [
-      /* @__PURE__ */ jsx17(Menu, {}),
-      /* @__PURE__ */ jsx17(
-        Box17,
+  return /* @__PURE__ */ jsxs21(Box22, { flexDirection: "column", height: "100%", width: "100%", children: [
+    /* @__PURE__ */ jsx22(Header, {}),
+    /* @__PURE__ */ jsxs21(Box22, { flexGrow: 1, flexDirection: "row", height: "100%", children: [
+      /* @__PURE__ */ jsx22(Menu, {}),
+      /* @__PURE__ */ jsx22(
+        Box22,
         {
           flexGrow: 1,
           borderStyle: "single",
           borderColor: theme.muted,
           flexDirection: "column",
           height: "100%",
-          children: /* @__PURE__ */ jsx17(ScreenComponent, {})
+          children: /* @__PURE__ */ jsx22(ScreenComponent, {})
         }
       )
     ] }),
-    /* @__PURE__ */ jsx17(LogFeed, {}),
-    modalOpen && modalContent && /* @__PURE__ */ jsx17(
-      Box17,
+    /* @__PURE__ */ jsx22(LogFeed, {}),
+    modalOpen && modalContent && /* @__PURE__ */ jsx22(
+      Box22,
       {
         position: "absolute",
         flexDirection: "column",
@@ -46064,20 +47922,20 @@ var App = () => {
 // src/tui/components/PathInput.tsx
 import fs10 from "fs/promises";
 import path8 from "path";
-import { Box as Box18, Text as Text17, useInput as useInput11 } from "ink";
-import { useEffect as useEffect13, useState as useState12 } from "react";
-import { jsx as jsx18, jsxs as jsxs17 } from "react/jsx-runtime";
+import { Box as Box23, Text as Text22, useInput as useInput16 } from "ink";
+import { useEffect as useEffect15, useState as useState17 } from "react";
+import { jsx as jsx23, jsxs as jsxs22 } from "react/jsx-runtime";
 
 // src/tui/components/StatusBar.tsx
-import { Box as Box19, Text as Text18 } from "ink";
-import { jsx as jsx19, jsxs as jsxs18 } from "react/jsx-runtime";
+import { Box as Box24, Text as Text23 } from "ink";
+import { jsx as jsx24, jsxs as jsxs23 } from "react/jsx-runtime";
 
 // src/tui/components/Toggle.tsx
-import { Box as Box20, Text as Text19, useInput as useInput12 } from "ink";
-import { jsx as jsx20, jsxs as jsxs19 } from "react/jsx-runtime";
+import { Box as Box25, Text as Text24, useInput as useInput17 } from "ink";
+import { jsx as jsx25, jsxs as jsxs24 } from "react/jsx-runtime";
 
 // src/tui/hooks/useLogs.ts
-import { useCallback as useCallback7, useEffect as useEffect14 } from "react";
+import { useCallback as useCallback7, useEffect as useEffect16 } from "react";
 
 // src/tui/mod.ts
 function launchTui() {
@@ -46085,7 +47943,7 @@ function launchTui() {
 }
 
 // src/mod.ts
-var VERSION2 = "1.5.4";
+var VERSION2 = "1.8.0";
 var APP_NAME = "Land of OZ - Valheim DSM";
 
 // main.ts