aegis-desktop 0.8.22 → 0.8.24

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "aegis-desktop",
   "productName": "AEGIS Desktop",
-  "version": "0.8.22",
+  "version": "0.8.24",
   "description": "Thin Electron host for AEGIS — a local chat UI over the shared client/aegis.js transport. Ships transport + UI only; engine logic stays server-side.",
   "author": {
     "name": "AEGIS Code",

package/vendor/platform.js

@@ -89,6 +89,24 @@ function defaultDirExists(dir) {
   }
 }
 
+/**
+ * Does this directory hold anything? Used only to break the OneDrive-vs-plain
+ * Desktop tie below — OneDrive routinely scaffolds an empty `OneDrive\Desktop`
+ * folder on install whether or not the user ever turned Desktop redirection
+ * on, so mere existence cannot tell a genuinely redirected Desktop apart from
+ * that empty placeholder. An unreadable/missing directory counts as empty
+ * rather than throwing, since the caller already confirmed it exists with
+ * `dirExists` and a race or permissions quirk here should not crash a
+ * best-effort path guess.
+ */
+function defaultDirNonEmpty(dir) {
+  try {
+    return fs.readdirSync(dir).length > 0;
+  } catch {
+    return false;
+  }
+}
+
 /** Read a text file; `null` for every failure (missing, unreadable, not text). */
 function defaultReadText(file) {
   try {
@@ -475,17 +493,56 @@ function hasPosixModes(options = {}) {
   return !win32;
 }
 
+/**
+ * Windows' own answer for "where is this user's Desktop", straight from the
+ * registry key Explorer itself reads and OneDrive itself rewrites when it
+ * redirects a folder. This is the one source immune to BOTH ways `~/Desktop`
+ * guesses wrong at once: it already names the OneDrive path when redirection
+ * is active, and it already names the LOCALISED folder — Swedish "Skrivbord",
+ * French "Bureau", whatever the session's physical folder is actually called
+ * — because it is Windows' own record of a real path, not an English-language
+ * guess with a `?` for an ending. Guessing per-language folder names instead
+ * would mean enumerating every language Windows ships, forever one behind;
+ * asking Windows is both simpler and exact.
+ *
+ * "Shell Folders" (not "User Shell Folders") is the one queried, because it
+ * holds the already-expanded absolute path — "User Shell Folders" is allowed
+ * to hold `%USERPROFILE%`-relative values, and this function has no reason to
+ * carry its own copy of Windows' expansion rules when the other key already
+ * did that work.
+ *
+ * Returns `''` on anything but a clean hit: `reg.exe` missing, a non-zero
+ * exit, unparsable output, or a path the filesystem does not actually have —
+ * each of those falls through to the candidate-guessing list in desktopDir()
+ * below, which is where this function's absence has always been tolerated.
+ */
+function winShellFolderDesktop(probe, dirExists) {
+  const out = probe('reg', [
+    'query',
+    'HKCU\\Software\\Microsoft\\Windows\\CurrentVersion\\Explorer\\Shell Folders',
+    '/v', 'Desktop',
+  ]);
+  if (!out) return '';
+  const m = /^\s*Desktop\s+REG_(?:EXPAND_)?SZ\s+(.+)$/im.exec(out);
+  const value = m && m[1].trim();
+  return value && dirExists(value) ? value : '';
+}
+
 /**
  * This user's real Desktop directory, or `''` when none can be found.
  *
  * `~/Desktop` is a GUESS, and it is wrong on both of the hosts this function was
  * added for:
  *
- *   - Windows with OneDrive. Folder redirection moves the live Desktop to
- *     `%USERPROFILE%\OneDrive\Desktop` and commonly leaves an empty
- *     `%USERPROFILE%\Desktop` behind, so a write to the obvious path lands in a
- *     directory the user is not looking at. `%OneDrive%` (set while OneDrive
- *     runs) is consulted first for exactly this case.
+ *   - Windows with OneDrive, or a localised session. Folder redirection moves
+ *     the live Desktop to `%USERPROFILE%\OneDrive\Desktop` (or renames it
+ *     entirely, e.g. Swedish "Skrivbord"), and commonly leaves an empty
+ *     `%USERPROFILE%\Desktop` behind, so a write to the obvious English path
+ *     lands in a directory the user is not looking at — or at a name that
+ *     does not exist on their machine at all. `winShellFolderDesktop()` above
+ *     asks Windows directly and settles both cases at once; the `%OneDrive%`-
+ *     and `home`-based guesses below only run when that lookup comes back
+ *     empty (no `reg.exe`, or the path it names no longer exists).
  *   - A localised Linux desktop. XDG translates the directory ITSELF, not just
  *     its label: a Swedish session has `~/Skrivbord` and no `~/Desktop` at all.
  *     `$XDG_DESKTOP_DIR` answers it, and `~/.config/user-dirs.dirs` is where
@@ -493,15 +550,24 @@ function hasPosixModes(options = {}) {
  *
  * macOS is the one host where `~/Desktop` is simply correct.
  *
- * Seams: `dirExists` (default: a real statSync isDirectory probe) and `readText`
- * (default: a real utf8 read, `null` on any failure), so all three branches are
- * exercised on one host.
+ * Seams: `dirExists` (default: a real statSync isDirectory probe), `dirNonEmpty`
+ * (default: a real readdirSync length check, used only to break the win32
+ * OneDrive-vs-plain guess below when the registry lookup did not settle it),
+ * `probe` (default: a real `reg.exe` spawn, `null` on any failure) and
+ * `readText` (default: a real utf8 read, `null` on any failure), so every
+ * branch is exercised on one host.
  */
 function desktopDir(options = {}) {
-  const { platform, env, win32, o } = seams(options);
+  const { platform, env, win32, probe, o } = seams(options);
   const P = win32 ? path.win32 : path.posix;
   const home = homeDir(options);
   const dirExists = typeof o.dirExists === 'function' ? o.dirExists : defaultDirExists;
+  const dirNonEmpty = typeof o.dirNonEmpty === 'function' ? o.dirNonEmpty : defaultDirNonEmpty;
+
+  if (win32) {
+    const fromRegistry = winShellFolderDesktop(probe, dirExists);
+    if (fromRegistry) return fromRegistry;
+  }
   const readText = typeof o.readText === 'function' ? o.readText : defaultReadText;
 
   const candidates = [];
@@ -514,6 +580,31 @@ function desktopDir(options = {}) {
     if (oneDrive) push(P.join(oneDrive, 'Desktop'));
     if (home) push(P.join(home, 'OneDrive', 'Desktop'));
     if (home) push(P.join(home, 'Desktop'));
+    // OneDrive is tried first above — real folder redirection moves the live
+    // Desktop there and leaves the plain one empty, exactly as the module
+    // comment says. But OneDrive also scaffolds an empty `OneDrive\Desktop`
+    // on install whether redirection was ever turned on, and that empty
+    // placeholder must not outrank a Desktop the user is actually using —
+    // reported live: a write landed in an untouched `OneDrive\Desktop` while
+    // the populated plain Desktop sat right next to it. Demote every
+    // OneDrive candidate below the plain one only in that one unambiguous
+    // case (a OneDrive candidate exists but is empty, AND the plain Desktop
+    // exists and has something in it); every other combination — including
+    // "both empty", which is what a fresh profile and this file's own
+    // stubbed tests both look like — keeps the order above, since a guess is
+    // still owed and emptiness alone proves nothing there.
+    const plainDesktop = home ? P.join(home, 'Desktop') : '';
+    const plainIdx = candidates.indexOf(plainDesktop);
+    if (plainIdx > 0 && dirExists(plainDesktop) && dirNonEmpty(plainDesktop)) {
+      const oneDriveCandidates = candidates.slice(0, plainIdx);
+      const allOneDriveEmpty = oneDriveCandidates.every(
+        (c) => !dirExists(c) || !dirNonEmpty(c)
+      );
+      if (allOneDriveEmpty) {
+        candidates.splice(plainIdx, 1);
+        candidates.unshift(plainDesktop);
+      }
+    }
   } else if (platform === 'darwin') {
     if (home) push(P.join(home, 'Desktop'));
   } else {