fix double drive_c issues

src/importer.js

@@ -5,7 +5,7 @@ const path = require('path')
 const { DIRS, resolvePortablePath } = require('./paths')
 const { newGame, newGameId, addGame } = require('./library')
 const { extractIconFromExe } = require('./icons')
-const { listPrefixes, prefixDriveRoot } = require('./prefixes')
+const { listPrefixes, prefixDriveRoots, isPrefixRoot } = require('./prefixes')
 const { rewireSymlinks } = require('./symlinks')
 const { copyTree, treeSize } = require('./fsutil')
 
@@ -22,6 +22,9 @@ function moveFolder(src, dst, onProgress) {
 }
 
 async function importGame(srcDir, mode, onProgress) {
+  // a prefix (or its drive_c / pfx) is not an app folder: copy/move would take
+  // the prefix's C: drive with it and leave the prefix gutted
+  if (isPrefixRoot(srcDir)) return { ok: false, error: 'prefix-root' }
   const name = path.basename(srcDir)
   // Validate before touching the user's files: refuse an import without any
   // .exe (and don't half-move a folder we'd then have to roll back).
@@ -71,17 +74,23 @@ async function importGame(srcDir, mode, onProgress) {
 // normally into C:\...
 async function importGameFromPrefix(prefix, srcDir, onProgress) {
   if (!listPrefixes().prefixes.some(p => p.name === prefix)) return { ok: false, error: 'prefix-not-found' }
-  // the folder must live inside the prefix's C: drive so the C:\ mapping
-  // holds - drive_c sits at the prefix top for plain wine, under pfx/ for
-  // Proton-managed prefixes
-  const driveRoot = prefixDriveRoot(prefix)
-  if (!driveRoot) return { ok: false, error: 'no-drive-c' }
-  const rel = path.relative(driveRoot, srcDir)
-  if (!rel || rel.startsWith('..') || path.isAbsolute(rel)) return { ok: false, error: 'outside-drive-c' }
-  const preExe = await findDefaultExe(srcDir)
+  // The folder must live inside one of the prefix's C: drives so the C:\
+  // mapping holds - drive_c sits at the prefix top for plain wine, under pfx/
+  // for Proton-managed prefixes, and a prefix used with BOTH kinds has both.
+  // Every existing drive_c counts; the stored path keeps its drive_c segment
+  // either way, so it resolves in the layout the app will run in.
+  const driveRoots = prefixDriveRoots(prefix)
+  if (!driveRoots.length) return { ok: false, error: 'no-drive-c' }
+  const src = path.resolve(String(srcDir))
+  const insideDrive = driveRoots.some(root => {
+    const rel = path.relative(root, src)
+    return rel && !rel.startsWith('..') && !path.isAbsolute(rel)
+  })
+  if (!insideDrive) return { ok: false, error: 'outside-drive-c' }
+  const preExe = await findDefaultExe(src)
   if (!preExe) return { ok: false, error: 'no-exe-found' }
   const id = newGameId()
-  const game = newGame({ id, name: path.basename(srcDir), exePath: preExe, workdir: srcDir, mode: 'prefix' })
+  const game = newGame({ id, name: path.basename(src), exePath: preExe, workdir: src, mode: 'prefix' })
   game.importSource = 'prefix'
   game.prefix = prefix
   // exe picked automatically -> grab its icon right away; a missing icon is

src/ipc/index.js

@@ -260,11 +260,14 @@ function registerIpc({ getWindow, onGamesChanged }) {
   // shows up for wine as a regular C:\ install
   ipcMain.handle('games:pickPrefixFolder', async (e, prefix) => {
     // open the picker straight in the prefix's C: drive (plain wine: top
-    // level, Proton: under pfx/)
-    const driveC = prefixes.prefixDriveRoot(prefix)
+    // level, Proton: under pfx/); a prefix used with BOTH kinds has two of
+    // them, so it opens at the prefix folder - the only spot that keeps
+    // drive_c and pfx/drive_c one click away
+    const driveRoots = prefixes.prefixDriveRoots(prefix)
+    const start = driveRoots.length === 1 ? driveRoots[0] : prefixes.prefixPath(prefix)
     const res = await dialog.showOpenDialog(getWindow(), {
       title: i18n.translate(library.loadSettings().language, 'import.pickPrefixFolder'),
-      defaultPath: driveC || prefixes.prefixPath(prefix),
+      defaultPath: start,
       properties: ['openDirectory']
     })
     return res.canceled || !res.filePaths[0] ? null : res.filePaths[0]

src/prefixes.js

@@ -41,22 +41,39 @@ function prefixExists(name) {
   }
 }
 
-// Where the Windows C: drive of a prefix actually lives: plain wine keeps
-// it at the top (WINEPREFIX=<prefix>), Proton-managed prefixes nest it
-// under pfx/ (WINEPREFIX=<prefix>/pfx). system.reg marks the real prefix
-// root; a fresh prefix may not have it yet, so fall back to drive_c itself.
-function prefixDriveRoot(name) {
+// Every Windows C: drive a prefix has: plain wine keeps one at the top
+// (WINEPREFIX=<prefix>), Proton-managed prefixes nest one under pfx/
+// (WINEPREFIX=<prefix>/pfx). A prefix used with BOTH wine kinds has both,
+// and an import may come from either one - so callers that can accept
+// several get them all, top level first.
+function prefixDriveRoots(name) {
   const root = prefixPath(name)
-  for (const pass of [true, false]) {
-    for (const base of [root, path.join(root, 'pfx')]) {
-      try {
-        const driveC = path.join(base, 'drive_c')
-        if (!fs.statSync(driveC).isDirectory()) continue
-        if (!pass || fs.existsSync(path.join(base, 'system.reg'))) return driveC
-      } catch {}
-    }
+  const found = []
+  for (const base of [root, path.join(root, 'pfx')]) {
+    try {
+      const driveC = path.join(base, 'drive_c')
+      if (fs.statSync(driveC).isDirectory()) found.push(driveC)
+    } catch {}
   }
-  return null
+  return found
+}
+
+// True when a path IS one of a prefix's own roots: the prefix folder, its
+// pfx/ or either drive_c. A copy/move import of such a folder would move the
+// prefix's C: drive (or the whole prefix) into files/apps, gutting it - the
+// "import from a prefix" flow is the one that works in place. Both drive
+// layouts are checked literally, not through prefixDriveRoots(): a prefix used
+// with wine AND Proton has a drive_c each and BOTH are off limits.
+function isPrefixRoot(p) {
+  if (!p) return false
+  const abs = path.resolve(String(p))
+  if (path.resolve(DIRS.PREFIXES) === abs) return true
+  for (const entry of listPrefixes().prefixes) {
+    const root = prefixPath(entry.name)
+    if (abs === root || abs === path.join(root, 'pfx')) return true
+    if (abs === path.join(root, 'drive_c') || abs === path.join(root, 'pfx', 'drive_c')) return true
+  }
+  return false
 }
 
 function createPrefix(name) {
@@ -136,4 +153,4 @@ function setDefaultPrefix(name) {
   return { ok: true }
 }
 
-module.exports = { listPrefixes, savePrefixes, createPrefix, deletePrefix, renamePrefix, setDefaultPrefix, prefixPath, prefixExists, prefixDriveRoot, healPrefix, MAIN }
+module.exports = { listPrefixes, savePrefixes, createPrefix, deletePrefix, renamePrefix, setDefaultPrefix, prefixPath, prefixExists, prefixDriveRoots, isPrefixRoot, healPrefix, MAIN }

src/runner.js

@@ -95,8 +95,13 @@ function buildEnv({ game, wine }) {
     env.PROTON_LOG_DIR = path.join(DIRS.DATA, 'logs')
     fs.mkdirSync(env.PROTON_LOG_DIR, { recursive: true })
     linkPrefix(env.STEAM_COMPAT_DATA_PATH, prefixDir)
+    // No silent fallback to a real directory: Proton would then set its prefix
+    // up under files/data/compat/<id>/pfx, outside files/wineprefixes/ where
+    // PLWL tracks it - rename, delete, the in-use guards and the LAN sync all
+    // look at the launcher prefix, so its C: drive would be orphaned. Only a
+    // missing path is refused; a populated one is linkPrefix's deliberate case.
     if (!fs.existsSync(env.STEAM_COMPAT_DATA_PATH)) {
-      fs.mkdirSync(env.STEAM_COMPAT_DATA_PATH, { recursive: true })
+      throw new Error('prefix-link-failed')
     }
   } else {
     // plain wine (system or imported build)