valheim-oz-dsm 1.4.3 → 1.5.1

package/dist/main.js

@@ -1690,7 +1690,7 @@ function parseValue(value) {
 }
 
 // src/cli/commands/doctor.ts
-import fs4 from "fs/promises";
+import fs3 from "fs/promises";
 import net from "net";
 import path4 from "path";
 import steamcmd4 from "@caleb-collar/steamcmd";
@@ -1810,9 +1810,87 @@ async function isValheimInstalled() {
     return false;
   }
 }
+function getRequiredValheimFiles() {
+  const platform = process.platform;
+  if (platform === "win32") {
+    return [
+      "valheim_server.exe",
+      "valheim_server_Data",
+      "UnityPlayer.dll",
+      "MonoBleedingEdge",
+      "steam_appid.txt"
+    ];
+  }
+  return [
+    "valheim_server.x86_64",
+    "valheim_server_Data",
+    "UnityPlayer.so",
+    "steam_appid.txt"
+  ];
+}
+async function verifyValheimInstallation() {
+  const { valheimDir } = getSteamPaths();
+  const requiredFiles = getRequiredValheimFiles();
+  const missingFiles = [];
+  const foundFiles = [];
+  try {
+    const dirStat = await fs2.stat(valheimDir);
+    if (!dirStat.isDirectory()) {
+      return {
+        valid: false,
+        message: "Valheim installation path exists but is not a directory",
+        missingFiles: requiredFiles,
+        foundFiles: [],
+        installPath: valheimDir
+      };
+    }
+  } catch {
+    return {
+      valid: false,
+      message: "Valheim dedicated server is not installed",
+      missingFiles: requiredFiles,
+      foundFiles: [],
+      installPath: valheimDir
+    };
+  }
+  for (const file of requiredFiles) {
+    const filePath = path3.join(valheimDir, file);
+    try {
+      await fs2.stat(filePath);
+      foundFiles.push(file);
+    } catch {
+      missingFiles.push(file);
+    }
+  }
+  if (missingFiles.length === 0) {
+    return {
+      valid: true,
+      message: "Valheim installation verified successfully",
+      missingFiles: [],
+      foundFiles,
+      installPath: valheimDir
+    };
+  }
+  const executableFile = process.platform === "win32" ? "valheim_server.exe" : "valheim_server.x86_64";
+  if (missingFiles.includes(executableFile)) {
+    return {
+      valid: false,
+      message: `Valheim server executable not found. Missing: ${missingFiles.join(", ")}`,
+      missingFiles,
+      foundFiles,
+      installPath: valheimDir
+    };
+  }
+  return {
+    valid: false,
+    message: `Valheim installation incomplete. Missing: ${missingFiles.join(", ")}`,
+    missingFiles,
+    foundFiles,
+    installPath: valheimDir
+  };
+}
 
 // src/steamcmd/updater.ts
-import fs3 from "fs/promises";
 import steamcmd3 from "@caleb-collar/steamcmd";
 var VALHEIM_APP_ID = 896660;
 function mapPhaseToStage2(phase) {
@@ -1829,7 +1907,6 @@ function mapPhaseToStage2(phase) {
   }
 }
 async function installValheim(onProgress) {
-  const { steamcmdDir } = getSteamPaths();
   const report = (status) => {
     onProgress?.(status);
   };
@@ -1842,10 +1919,6 @@ async function installValheim(onProgress) {
     });
     throw new Error("SteamCMD is not installed");
   }
-  try {
-    await fs3.mkdir(steamcmdDir, { recursive: true });
-  } catch {
-  }
   report({
     stage: "downloading",
     progress: 0,
@@ -1854,7 +1927,6 @@ async function installValheim(onProgress) {
   try {
     await steamcmd3.install({
       applicationId: VALHEIM_APP_ID,
-      path: steamcmdDir,
       onProgress: (p) => {
         const stage = mapPhaseToStage2(p.phase);
         const progress = p.percent ?? 0;
@@ -1935,7 +2007,7 @@ async function getInstalledVersion() {
 // src/cli/commands/doctor.ts
 async function exists(filePath) {
   try {
-    await fs4.access(filePath);
+    await fs3.access(filePath);
     return true;
   } catch {
     return false;
@@ -2083,9 +2155,9 @@ async function checkPermissions() {
   const steamCmdDir = info2.directory;
   const testFile = path4.join(steamCmdDir, ".oz-test-write");
   try {
-    await fs4.mkdir(steamCmdDir, { recursive: true });
-    await fs4.writeFile(testFile, "test");
-    await fs4.unlink(testFile);
+    await fs3.mkdir(steamCmdDir, { recursive: true });
+    await fs3.writeFile(testFile, "test");
+    await fs3.unlink(testFile);
     return {
       name: "Directory Permissions",
       status: "pass",
@@ -2196,7 +2268,7 @@ Summary: ${passed} passed, ${warnings} warnings, ${failed} failed
 }
 
 // src/cli/commands/install.ts
-import * as fs5 from "fs/promises";
+import * as fs4 from "fs/promises";
 async function installCommand(args) {
   const steamInstalled = await isSteamCmdInstalled();
   const valheimInstalled = await isValheimInstalled();
@@ -2259,7 +2331,7 @@ async function validateInstallation(steamInstalled, valheimInstalled, paths) {
     console.log("    \u2713 Installed");
     console.log(`    Path: ${paths.steamcmd}`);
     try {
-      const stat3 = await fs5.stat(paths.steamcmd);
+      const stat3 = await fs4.stat(paths.steamcmd);
       if (stat3.isFile()) {
         console.log("    \u2713 Executable found");
       }
@@ -2278,7 +2350,7 @@ async function validateInstallation(steamInstalled, valheimInstalled, paths) {
     console.log(`    Path: ${paths.valheimDir}`);
     const exePath = `${paths.valheimDir}/${paths.executable}`;
     try {
-      const stat3 = await fs5.stat(exePath);
+      const stat3 = await fs4.stat(exePath);
       if (stat3.isFile()) {
         console.log("    \u2713 Executable found");
       }
@@ -2493,7 +2565,7 @@ async function interactiveRcon(args) {
 }
 
 // src/server/commands.ts
-import * as fs6 from "fs/promises";
+import * as fs5 from "fs/promises";
 import { dirname, join } from "path";
 
 // src/server/logs.ts
@@ -2544,7 +2616,7 @@ function parseEvent(line) {
 }
 
 // src/server/pidfile.ts
-import fs7 from "fs/promises";
+import fs6 from "fs/promises";
 import path5 from "path";
 function getPidFilePath() {
   return path5.join(getConfigDir(), "oz-valheim", "server.pid");
@@ -2552,13 +2624,13 @@ function getPidFilePath() {
 async function writePidFile(data) {
   const pidPath = getPidFilePath();
   const dir = path5.dirname(pidPath);
-  await fs7.mkdir(dir, { recursive: true });
-  await fs7.writeFile(pidPath, JSON.stringify(data, null, 2), "utf-8");
+  await fs6.mkdir(dir, { recursive: true });
+  await fs6.writeFile(pidPath, JSON.stringify(data, null, 2), "utf-8");
 }
 async function readPidFile() {
   const pidPath = getPidFilePath();
   try {
-    const content = await fs7.readFile(pidPath, "utf-8");
+    const content = await fs6.readFile(pidPath, "utf-8");
     return JSON.parse(content);
   } catch {
     return null;
@@ -2567,7 +2639,7 @@ async function readPidFile() {
 async function removePidFile() {
   const pidPath = getPidFilePath();
   try {
-    await fs7.unlink(pidPath);
+    await fs6.unlink(pidPath);
   } catch {
   }
 }
@@ -3200,29 +3272,29 @@ Found running server:`);
 }
 
 // src/cli/commands/worlds.ts
-import * as fs10 from "fs/promises";
+import * as fs9 from "fs/promises";
 
 // src/valheim/lists.ts
-import fs8 from "fs/promises";
+import fs7 from "fs/promises";
 import path6 from "path";
 
 // src/valheim/worlds.ts
-import fs9 from "fs/promises";
+import fs8 from "fs/promises";
 import path7 from "path";
 import process3 from "process";
 async function exists2(filePath) {
   try {
-    await fs9.access(filePath);
+    await fs8.access(filePath);
     return true;
   } catch {
     return false;
   }
 }
 async function ensureDir(dirPath) {
-  await fs9.mkdir(dirPath, { recursive: true });
+  await fs8.mkdir(dirPath, { recursive: true });
 }
 async function copyFile(src, dest) {
-  await fs9.copyFile(src, dest);
+  await fs8.copyFile(src, dest);
 }
 function getValheimBaseDir() {
   const platform = getPlatform();
@@ -3276,7 +3348,7 @@ async function listWorldsFromDir(dir, source) {
   const worlds = [];
   const foundNames = /* @__PURE__ */ new Set();
   try {
-    const entries = await fs9.readdir(dir, { withFileTypes: true });
+    const entries = await fs8.readdir(dir, { withFileTypes: true });
     for (const entry of entries) {
       if (entry.isFile() && entry.name.endsWith(".db")) {
         if (entry.name.includes(".db.")) continue;
@@ -3284,7 +3356,7 @@ async function listWorldsFromDir(dir, source) {
         const dbPath = path7.join(dir, entry.name);
         const fwlPath = path7.join(dir, `${name}.fwl`);
         if (!await exists2(fwlPath)) continue;
-        const dbStat = await fs9.stat(dbPath);
+        const dbStat = await fs8.stat(dbPath);
         foundNames.add(name);
         const backupInfo = parseBackupName(name);
         worlds.push({
@@ -3309,7 +3381,7 @@ async function listWorldsFromDir(dir, source) {
         if (foundNames.has(name)) continue;
         const fwlPath = path7.join(dir, entry.name);
         const dbPath = path7.join(dir, `${name}.db`);
-        const fwlStat = await fs9.stat(fwlPath);
+        const fwlStat = await fs8.stat(fwlPath);
         const backupInfo = parseBackupName(name);
         worlds.push({
           name,
@@ -3405,7 +3477,7 @@ async function importWorld(dbPath, fwlPath, targetDir) {
   const targetFwl = path7.join(dir, `${name}.fwl`);
   await copyFile(dbPath, targetDb);
   await copyFile(fwlPath, targetFwl);
-  const stat3 = await fs9.stat(targetDb);
+  const stat3 = await fs8.stat(targetDb);
   const serverDir = getDedicatedServerWorldsDir();
   const cloudDir = getCloudWorldsDir();
   const source = dir === serverDir ? "server" : dir === cloudDir ? "cloud" : "local";
@@ -3461,16 +3533,16 @@ async function deleteWorld(worldName, worldsDir) {
     throw new Error(`World "${worldName}" not found`);
   }
   if (dbExists) {
-    await fs9.unlink(dbPath);
+    await fs8.unlink(dbPath);
   }
   if (fwlExists) {
-    await fs9.unlink(fwlPath);
+    await fs8.unlink(fwlPath);
   }
   try {
-    const entries = await fs9.readdir(dir, { withFileTypes: true });
+    const entries = await fs8.readdir(dir, { withFileTypes: true });
     for (const entry of entries) {
       if (entry.name.startsWith(`${worldName}.db.`) || entry.name.startsWith(`${worldName}.fwl.`)) {
-        await fs9.unlink(path7.join(dir, entry.name));
+        await fs8.unlink(path7.join(dir, entry.name));
       }
     }
   } catch {
@@ -3588,7 +3660,7 @@ World: ${world.name}`);
     console.log(`Size: ${sizeMb} MB`);
     console.log(`Last modified: ${world.modified.toLocaleString()}`);
     try {
-      const fwlContent = await fs10.readFile(world.fwlPath, "utf-8");
+      const fwlContent = await fs9.readFile(world.fwlPath, "utf-8");
       if (fwlContent.length > 0) {
         console.log("");
         console.log(
@@ -3620,8 +3692,8 @@ Importing world '${name}'...`);
   console.log(`  From: ${path9}`);
   try {
     try {
-      await fs10.stat(dbPath);
-      await fs10.stat(fwlPath);
+      await fs9.stat(dbPath);
+      await fs9.stat(fwlPath);
     } catch {
       console.error("\nError: World files not found.");
       console.log(`  Expected: ${dbPath}`);
@@ -3721,7 +3793,7 @@ import { useEffect as useEffect3, useMemo as useMemo2, useRef as useRef2, useSta
 // package.json
 var package_default = {
   name: "valheim-oz-dsm",
-  version: "1.4.3",
+  version: "1.5.1",
   description: "Land of OZ - Valheim Dedicated Server Manager",
   type: "module",
   bin: {
@@ -3911,6 +3983,16 @@ var useStore = create((set) => ({
     installPercent: 0,
     path: null
   },
+  // Initial Valheim server state
+  valheim: {
+    installed: null,
+    installing: false,
+    installProgress: "",
+    installPercent: 0,
+    path: null,
+    verified: null,
+    buildId: null
+  },
   // Actions
   actions: {
     // Server actions
@@ -4096,6 +4178,37 @@ var useStore = create((set) => ({
         installProgress: "",
         installPercent: 0
       }
+    })),
+    // Valheim server actions
+    setValheimInstalled: (installed) => set((state) => ({
+      valheim: { ...state.valheim, installed }
+    })),
+    setValheimInstalling: (installing) => set((state) => ({
+      valheim: { ...state.valheim, installing }
+    })),
+    setValheimInstallProgress: (message, percent) => set((state) => ({
+      valheim: {
+        ...state.valheim,
+        installProgress: message,
+        installPercent: percent
+      }
+    })),
+    setValheimPath: (path9) => set((state) => ({
+      valheim: { ...state.valheim, path: path9 }
+    })),
+    setValheimVerified: (verified) => set((state) => ({
+      valheim: { ...state.valheim, verified }
+    })),
+    setValheimBuildId: (buildId) => set((state) => ({
+      valheim: { ...state.valheim, buildId }
+    })),
+    resetValheimInstall: () => set((state) => ({
+      valheim: {
+        ...state.valheim,
+        installing: false,
+        installProgress: "",
+        installPercent: 0
+      }
     }))
   }
 }));
@@ -43317,6 +43430,22 @@ var Dashboard = () => {
   );
   const setSteamCmdPath = useStore((s) => s.actions.setSteamCmdPath);
   const resetSteamCmdInstall = useStore((s) => s.actions.resetSteamCmdInstall);
+  const valheimInstalled = useStore((s) => s.valheim.installed);
+  const valheimInstalling = useStore((s) => s.valheim.installing);
+  const valheimProgress = useStore((s) => s.valheim.installProgress);
+  const valheimPercent = useStore((s) => s.valheim.installPercent);
+  const valheimPath = useStore((s) => s.valheim.path);
+  const valheimVerified = useStore((s) => s.valheim.verified);
+  const valheimBuildId = useStore((s) => s.valheim.buildId);
+  const setValheimInstalled = useStore((s) => s.actions.setValheimInstalled);
+  const setValheimInstalling = useStore((s) => s.actions.setValheimInstalling);
+  const setValheimInstallProgress = useStore(
+    (s) => s.actions.setValheimInstallProgress
+  );
+  const setValheimPath = useStore((s) => s.actions.setValheimPath);
+  const setValheimVerified = useStore((s) => s.actions.setValheimVerified);
+  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("");
@@ -43338,6 +43467,96 @@ var Dashboard = () => {
     };
     checkSteamCmd2();
   }, [setSteamCmdInstalled, setSteamCmdPath]);
+  useEffect7(() => {
+    if (steamCmdInstalled !== true) return;
+    const checkValheim = async () => {
+      try {
+        const installed = await isValheimInstalled();
+        setValheimInstalled(installed);
+        if (installed) {
+          const paths = getSteamPaths();
+          setValheimPath(paths.valheimDir);
+          const verification = await verifyValheimInstallation();
+          setValheimVerified(verification.valid);
+          if (!verification.valid) {
+            addLog("warn", verification.message);
+          }
+          const buildId = await getInstalledVersion();
+          setValheimBuildId(buildId);
+        }
+      } catch {
+        setValheimInstalled(false);
+        setValheimVerified(false);
+      }
+    };
+    checkValheim();
+  }, [
+    steamCmdInstalled,
+    setValheimInstalled,
+    setValheimPath,
+    setValheimVerified,
+    setValheimBuildId,
+    addLog
+  ]);
+  useEffect7(() => {
+    if (steamCmdInstalled === true && valheimInstalled === false && !valheimInstalling) {
+      const autoInstallValheim = async () => {
+        setValheimInstalling(true);
+        addLog("info", "Auto-installing Valheim Dedicated Server...");
+        try {
+          await installValheim((status2) => {
+            setValheimInstallProgress(status2.message, status2.progress);
+            if (status2.stage === "complete") {
+              addLog(
+                "info",
+                "Valheim Dedicated Server installed successfully!"
+              );
+            }
+          });
+          setValheimInstalled(true);
+          const paths = getSteamPaths();
+          setValheimPath(paths.valheimDir);
+          const verification = await verifyValheimInstallation();
+          setValheimVerified(verification.valid);
+          if (verification.valid) {
+            addLog(
+              "info",
+              `Installation verified at: ${verification.installPath}`
+            );
+          } else {
+            addLog("warn", verification.message);
+          }
+          const buildId = await getInstalledVersion();
+          setValheimBuildId(buildId);
+          if (buildId) {
+            addLog("info", `Valheim build ID: ${buildId}`);
+          }
+        } catch (error2) {
+          addLog(
+            "error",
+            `Valheim installation failed: ${error2 instanceof Error ? error2.message : String(error2)}`
+          );
+          setValheimInstalled(false);
+          setValheimVerified(false);
+        } finally {
+          resetValheimInstall();
+        }
+      };
+      autoInstallValheim();
+    }
+  }, [
+    steamCmdInstalled,
+    valheimInstalled,
+    valheimInstalling,
+    setValheimInstalling,
+    setValheimInstallProgress,
+    setValheimInstalled,
+    setValheimPath,
+    setValheimVerified,
+    setValheimBuildId,
+    resetValheimInstall,
+    addLog
+  ]);
   useEffect7(() => {
     const checkStartupTask = async () => {
       try {
@@ -43373,6 +43592,43 @@ var Dashboard = () => {
       resetSteamCmdInstall();
     }
   };
+  const handleInstallValheim = async () => {
+    closeModal();
+    setValheimInstalling(true);
+    addLog("info", "Starting Valheim Dedicated Server installation...");
+    try {
+      await installValheim((status2) => {
+        setValheimInstallProgress(status2.message, status2.progress);
+        if (status2.stage === "complete") {
+          addLog("info", "Valheim Dedicated Server installed successfully!");
+        }
+      });
+      setValheimInstalled(true);
+      const paths = getSteamPaths();
+      setValheimPath(paths.valheimDir);
+      const verification = await verifyValheimInstallation();
+      setValheimVerified(verification.valid);
+      if (verification.valid) {
+        addLog("info", `Installation verified at: ${verification.installPath}`);
+      } else {
+        addLog("warn", verification.message);
+      }
+      const buildId = await getInstalledVersion();
+      setValheimBuildId(buildId);
+      if (buildId) {
+        addLog("info", `Valheim build ID: ${buildId}`);
+      }
+    } catch (error2) {
+      addLog(
+        "error",
+        `Valheim installation failed: ${error2 instanceof Error ? error2.message : String(error2)}`
+      );
+      setValheimInstalled(false);
+      setValheimVerified(false);
+    } finally {
+      resetValheimInstall();
+    }
+  };
   const handleStopConfirm = () => {
     closeModal();
     stop();
@@ -43444,10 +43700,10 @@ var Dashboard = () => {
     }
   };
   useInput4((input) => {
-    if (modalOpen || isUpdating2 || steamCmdInstalling || startupTaskProcessing)
+    if (modalOpen || isUpdating2 || steamCmdInstalling || valheimInstalling || startupTaskProcessing)
       return;
     if (input === "s" || input === "S") {
-      if (status === "offline" && steamCmdInstalled) {
+      if (status === "offline" && steamCmdInstalled && valheimInstalled) {
         start();
         addLog("info", "Starting server...");
       }
@@ -43481,7 +43737,7 @@ var Dashboard = () => {
       }
     }
     if (input === "u" || input === "U") {
-      if (status === "offline" && steamCmdInstalled) {
+      if (status === "offline" && steamCmdInstalled && valheimInstalled) {
         openModal(
           /* @__PURE__ */ jsx11(
             ConfirmModal,
@@ -43508,6 +43764,21 @@ var Dashboard = () => {
         );
       }
     }
+    if (input === "v" || input === "V") {
+      if (steamCmdInstalled && !valheimInstalling) {
+        const action = valheimInstalled === false ? "Install" : "Reinstall/Verify";
+        openModal(
+          /* @__PURE__ */ jsx11(
+            ConfirmModal,
+            {
+              message: `${action} Valheim Dedicated Server? This may take several minutes.`,
+              onConfirm: handleInstallValheim,
+              onCancel: closeModal
+            }
+          )
+        );
+      }
+    }
     if (input === "f" || input === "F") {
       if (status === "online") {
         handleForceSave();
@@ -43614,6 +43885,28 @@ var Dashboard = () => {
       )
     ] });
   }
+  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,
+        {
+          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: [
+              valheimProgress,
+              valheimPercent > 0 && ` (${valheimPercent}%)`
+            ] }) }),
+            /* @__PURE__ */ jsx11(Box11, { marginTop: 1, children: /* @__PURE__ */ jsx11(Text11, { 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: [
@@ -43629,6 +43922,27 @@ var Dashboard = () => {
         ] })
       ] })
     ] }),
+    /* @__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" })
+        ] }),
+        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 && valheimBuildId && /* @__PURE__ */ jsxs10(Box11, { flexShrink: 0, children: [
+          /* @__PURE__ */ jsx11(Text11, { children: "Build ID: " }),
+          /* @__PURE__ */ jsx11(Text11, { dimColor: true, children: valheimBuildId })
+        ] }),
+        valheimInstalled && valheimPath && /* @__PURE__ */ jsxs10(Box11, { flexShrink: 0, children: [
+          /* @__PURE__ */ jsx11(Text11, { children: "Location: " }),
+          /* @__PURE__ */ jsx11(Text11, { 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: [
@@ -43697,7 +44011,17 @@ var Dashboard = () => {
           /* @__PURE__ */ jsx11(Text11, { children: "Install SteamCMD" }),
           /* @__PURE__ */ jsx11(Text11, { color: theme.warning, children: " (required)" })
         ] }) }),
-        steamCmdInstalled ? status === "offline" ? /* @__PURE__ */ jsxs10(Box11, { flexDirection: "column", children: [
+        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 && 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 ? 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" })
@@ -43706,6 +44030,10 @@ var Dashboard = () => {
             /* @__PURE__ */ jsx11(Text11, { color: theme.info, children: "[U] " }),
             /* @__PURE__ */ jsx11(Text11, { children: "Update Server" }),
             updateAvailable && /* @__PURE__ */ jsx11(Text11, { 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" })
           ] })
         ] }) : status === "online" ? /* @__PURE__ */ jsxs10(Box11, { flexDirection: "column", children: [
           /* @__PURE__ */ jsxs10(Box11, { flexShrink: 0, children: [
@@ -43730,7 +44058,7 @@ var Dashboard = () => {
             /* @__PURE__ */ jsx11(Text11, { color: theme.error, children: "[K] " }),
             /* @__PURE__ */ jsx11(Text11, { dimColor: true, children: "Force Kill (if stuck)" })
           ] })
-        ] }) : steamCmdInstalled === null ? /* @__PURE__ */ jsx11(Text11, { dimColor: true, children: "Checking SteamCMD status..." }) : /* @__PURE__ */ jsx11(Text11, { dimColor: true, children: "Install SteamCMD to manage server" }),
+        ] }) : 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,
@@ -45655,7 +45983,7 @@ var App = () => {
 };
 
 // src/tui/components/PathInput.tsx
-import fs11 from "fs/promises";
+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";
@@ -45678,7 +46006,7 @@ function launchTui() {
 }
 
 // src/mod.ts
-var VERSION2 = "1.4.3";
+var VERSION2 = "1.5.1";
 var APP_NAME = "Land of OZ - Valheim DSM";
 
 // main.ts