valheim-oz-dsm 1.5.4 → 1.6.1

package/dist/main.js

@@ -2644,6 +2644,25 @@ 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+)/);
@@ -2690,9 +2709,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 +2935,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 +2975,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 +2992,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 +3002,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 +3028,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 +3045,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 +3217,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 +3269,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 +3292,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 +3637,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 +3658,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 +3668,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 +3682,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 +3716,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 +3756,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 +3786,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 +3808,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();
@@ -3868,7 +4383,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.6.1",
   description: "Land of OZ - Valheim Dedicated Server Manager",
   type: "module",
   bin: {
@@ -3877,7 +4392,6 @@ var package_default = {
   main: "./dist/main.js",
   files: [
     "dist",
-    "patches",
     "README.md",
     "LICENSE",
     "CHANGELOG.md"
@@ -3898,12 +4412,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 +4429,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",
@@ -43116,46 +43628,81 @@ var Spinner = (props) => {
 };
 
 // src/tui/hooks/useServer.ts
-import { useCallback as useCallback3, useEffect as useEffect6 } from "react";
+import { useCallback as useCallback3, useEffect as useEffect6, 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 +43711,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 +43786,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 +43858,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]);
+  useEffect6(() => {
+    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,6 +44010,18 @@ function useServer() {
       actions.addLog("error", `Failed to send save command: ${error2}`);
     }
   }, [rcon, actions]);
+  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]);
   useEffect6(() => {
     if (status !== "online") return;
     const interval = setInterval(() => {
@@ -43420,10 +44037,14 @@ 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()
   };
 }
@@ -46085,7 +46706,7 @@ function launchTui() {
 }
 
 // src/mod.ts
-var VERSION2 = "1.5.4";
+var VERSION2 = "1.6.1";
 var APP_NAME = "Land of OZ - Valheim DSM";
 
 // main.ts