Fix workspace switch race condition, gh auth detection, and file open perf

Fix three open bugs (#581, #551, #572):

1. Bug #581 - Workspace State Not Preserved When Switching Folders:
   Move closeBuffersBatch() before new project loading in switchToProject()
   to prevent race conditions between session save and restore. Old
   terminal PTY processes are now cleaned up before new ones are spawned.

2. Bug #551 - Athas not detecting that GitHub CLI is authenticated:
   Parse gh auth status stderr for authentication indicators instead of
   relying solely on exit code. gh auth status can return exit code 0 even
   when the token is expired or invalid (see cli/cli#8845). Now checks for
   'Logged in to' as positive confirmation and 'not logged in',
   'token is invalid', 'Failed to log in' as failure indicators.

3. Bug #572 - Athas Lags on CachyOS / File Opening Performance:
   Remove per-entry symlink resolution from readDirectoryContents() that
   caused hundreds of stat syscalls during directory listing. Symlinks are
   still resolved lazily when files are opened. Also combine binary
   sniffing and content reading into a single readFile() call, eliminating
   the double-read that occurred for every file open.

Co-authored-by: factory-droid[bot] <138933559+factory-droid[bot]@users.noreply.github.com>

Author: RajPabnani03

crates/github/src/api.rs

@@ -40,9 +40,31 @@ pub fn github_check_cli_status(app: AppHandle) -> Result<GitHubCliStatus, String
       .output()
       .map_err(|e| format!("Failed to execute gh command: {}", e))?;
 
+   // gh auth status reports results on stderr. On some versions, exit code 0
+   // is returned even when the token is expired or invalid (see cli/cli#8845).
+   // Parse stderr to look for authentication failure indicators instead of
+   // relying solely on the exit code.
+   let stderr = String::from_utf8_lossy(&output.stderr);
+
    if output.status.success() {
-      Ok(GitHubCliStatus::Authenticated)
+      // Exit code 0, but verify the output actually confirms authentication.
+      // A successful auth status contains "Logged in to" on stderr.
+      if stderr.contains("Logged in to") {
+         Ok(GitHubCliStatus::Authenticated)
+      } else if stderr.contains("not logged in")
+         || stderr.contains("no authentications")
+         || stderr.contains("token is invalid")
+         || stderr.contains("Failed to log in")
+         || (stderr.contains("The token") && stderr.contains("is invalid"))
+      {
+         // Token exists but is invalid/expired — gh still exits 0 in some versions
+         Ok(GitHubCliStatus::NotAuthenticated)
+      } else {
+         // Exit code 0 with no recognizable failure — assume authenticated
+         Ok(GitHubCliStatus::Authenticated)
+      }
    } else {
+      // Non-zero exit code always means not authenticated
       Ok(GitHubCliStatus::NotAuthenticated)
    }
 }

src/features/file-system/controllers/file-operations.ts

@@ -1,13 +1,11 @@
 import type { FileEntry } from "../types/app";
 import {
-  getSymlinkInfo,
   createDirectory as platformCreateDirectory,
   deletePath as platformDeletePath,
   readDirectory as platformReadDirectory,
   readFile as platformReadFile,
   writeFile as platformWriteFile,
 } from "./platform";
-import { useFileSystemStore } from "./store";
 import { shouldIgnore } from "./utils";
 
 export async function readFileContent(path: string): Promise<string> {
@@ -60,42 +58,26 @@ export async function deleteFileOrDirectory(path: string): Promise<void> {
 export async function readDirectoryContents(path: string): Promise<FileEntry[]> {
   try {
     const entries = await platformReadDirectory(path);
-    const workspaceRoot = useFileSystemStore.getState().rootFolderPath;
 
     const filteredEntries = (entries as any[]).filter((entry: any) => {
       const name = entry.name || "Unknown";
       const isDir = entry.is_dir || false;
       return !shouldIgnore(name, isDir);
     });
 
-    const entriesWithSymlinkInfo = await Promise.all(
-      filteredEntries.map(async (entry: any) => {
-        const entryPath = entry.path || `${path}/${entry.name}`;
-
-        try {
-          const symlinkInfo = await getSymlinkInfo(entryPath, workspaceRoot);
-
-          return {
-            name: entry.name || "Unknown",
-            path: entryPath,
-            isDir: symlinkInfo.is_symlink ? false : entry.is_dir || false,
-            children: undefined,
-            isSymlink: symlinkInfo.is_symlink,
-            symlinkTarget: symlinkInfo.target,
-          };
-        } catch (error) {
-          console.error(`Failed to get symlink info for ${entryPath}:`, error);
-          return {
-            name: entry.name || "Unknown",
-            path: entryPath,
-            isDir: entry.is_dir || false,
-            children: undefined,
-          };
-        }
-      }),
-    );
-
-    return entriesWithSymlinkInfo;
+    // Skip per-entry symlink resolution during initial directory read.
+    // Symlink info is resolved lazily when a file is opened (handleFileSelect)
+    // or a directory is expanded, avoiding hundreds of stat syscalls that
+    // cause significant lag on large projects (see #572).
+    return filteredEntries.map((entry: any) => {
+      const entryPath = entry.path || `${path}/${entry.name}`;
+      return {
+        name: entry.name || "Unknown",
+        path: entryPath,
+        isDir: entry.is_dir || false,
+        children: undefined,
+      };
+    });
   } catch (error) {
     throw new Error(`Failed to read directory ${path}: ${error}`);
   }

src/features/file-system/controllers/store.ts

@@ -42,7 +42,6 @@ import {
   createNewFile,
   deleteFileOrDirectory,
   readDirectoryContents,
-  readFileContent,
 } from "./file-operations";
 import {
   addFileToTree,
@@ -791,38 +790,6 @@ export const useFileSystemStore = createSelectors(
           );
           fileOpenBenchmark.finish(path, "binary-buffer-opened");
         } else {
-          if (!path.startsWith("remote://")) {
-            try {
-              const fileData = await readFile(resolvedPath);
-
-              if (isStaleRequest()) return;
-
-              if (isBinaryContent(fileData)) {
-                openBuffer(
-                  path,
-                  fileName,
-                  "",
-                  false,
-                  undefined,
-                  false,
-                  false,
-                  undefined,
-                  false,
-                  false,
-                  false,
-                  undefined,
-                  false,
-                  false,
-                  true,
-                );
-                fileOpenBenchmark.finish(path, "binary-sniff-buffer-opened");
-                return;
-              }
-            } catch (error) {
-              console.error("Failed to inspect file bytes before opening:", error);
-            }
-          }
-
           // Check if external editor is enabled for text files
           const { settings } = useSettingsStore.getState();
           const { openExternalEditorBuffer } = useBufferStore.getState().actions;
@@ -867,7 +834,38 @@ export const useFileSystemStore = createSelectors(
               filePath: remotePath,
             });
           } else {
-            content = await readFileContent(resolvedPath);
+            // Read file as binary first to perform binary sniffing without
+            // a separate read pass (avoids reading large files twice, see #572).
+            const fileData = await readFile(resolvedPath);
+            fileOpenBenchmark.mark(path, "file-read-bytes", `${fileData.length} bytes`);
+
+            if (isStaleRequest()) return;
+
+            if (isBinaryContent(fileData)) {
+              openBuffer(
+                path,
+                fileName,
+                "",
+                false,
+                undefined,
+                false,
+                false,
+                undefined,
+                false,
+                false,
+                false,
+                undefined,
+                false,
+                false,
+                true,
+              );
+              fileOpenBenchmark.finish(path, "binary-sniff-buffer-opened");
+              return;
+            }
+
+            // Decode the already-read bytes instead of reading the file again
+            const decoder = new TextDecoder("utf-8");
+            content = decoder.decode(fileData);
           }
           fileOpenBenchmark.mark(path, "file-read", `${content.length} chars`);
 
@@ -1914,6 +1912,14 @@ export const useFileSystemStore = createSelectors(
 
           useWorkspaceTabsStore.getState().setActiveProjectTab(projectId);
 
+          // Close old project's buffers BEFORE loading new project to prevent
+          // race conditions between session save and restore, and to ensure
+          // terminal PTY processes from the old workspace are cleaned up
+          // before new ones are spawned.
+          if (currentBufferIds.length > 0) {
+            bufferActions.closeBuffersBatch(currentBufferIds, true);
+          }
+
           if (remoteTabInfo) {
             const reconnected = await get().handleOpenRemoteProject(
               remoteTabInfo.connectionId,
@@ -2060,10 +2066,6 @@ export const useFileSystemStore = createSelectors(
             })();
           }
 
-          if (currentBufferIds.length > 0) {
-            bufferActions.closeBuffersBatch(currentBufferIds, true);
-          }
-
           set((state) => {
             state.isSwitchingProject = false;
           });