feat: add workspace reset and file hygiene

Author: akgohain

client/src/views/FilesManager.js

@@ -1,6 +1,7 @@
-import React, { useState, useEffect, useRef } from "react";
+import React, { useState, useEffect, useRef, useContext } from "react";
 import {
   Button,
+  Dropdown,
   Input,
   Modal,
   message,
@@ -21,10 +22,13 @@ import {
   UploadOutlined,
   EyeOutlined,
   LayoutOutlined,
+  MoreOutlined,
+  DeleteOutlined,
 } from "@ant-design/icons";
 import { apiClient } from "../api";
 import FileTreeSidebar from "../components/FileTreeSidebar";
 import { openLocalFile, revealInFinder } from "../electronApi";
+import { AppContext } from "../contexts/GlobalContext";
 
 const HIDDEN_SYSTEM_FILES = new Set([
   "workflow_preference.json",
@@ -77,6 +81,7 @@ const transformFiles = (fileList) => {
 };
 
 function FilesManager() {
+  const context = useContext(AppContext);
   const [folders, setFolders] = useState([]);
   const [files, setFiles] = useState({});
   const [currentFolder, setCurrentFolder] = useState("root");
@@ -1202,6 +1207,79 @@ function FilesManager() {
     }
   };
 
+  const handleResetWorkspace = () => {
+    Modal.confirm({
+      title: "Reset workspace?",
+      content:
+        "This clears indexed mounted projects and uploaded app files for the current workspace. Source project directories on disk are preserved.",
+      okText: "Continue",
+      okButtonProps: { danger: true },
+      cancelText: "Cancel",
+      onOk: async () => {
+        let confirmText = "";
+        let finalConfirmModal = null;
+
+        finalConfirmModal = Modal.confirm({
+          title: "Final confirmation required",
+          content: (
+            <div>
+              <div style={{ marginBottom: 8 }}>
+                Type <strong>RESET</strong> to clear this workspace.
+              </div>
+              <Input
+                placeholder='Type "RESET"'
+                onChange={(e) => {
+                  confirmText = e.target.value;
+                  if (finalConfirmModal) {
+                    finalConfirmModal.update({
+                      okButtonProps: {
+                        danger: true,
+                        disabled: confirmText.trim() !== "RESET",
+                      },
+                    });
+                  }
+                }}
+              />
+            </div>
+          ),
+          okText: "Reset Workspace",
+          okButtonProps: { danger: true, disabled: true },
+          cancelText: "Cancel",
+          onOk: async () => {
+            if (confirmText.trim() !== "RESET") {
+              return;
+            }
+
+            try {
+              const res = await apiClient.delete("/files/workspace", {
+                withCredentials: true,
+              });
+              await context.resetFileState();
+              await fetchFiles();
+              handleNavigate("root");
+              setSelectedItems([]);
+              message.success(
+                `Workspace reset. Removed ${res?.data?.deleted_count ?? 0} indexed item(s).`,
+              );
+            } catch (err) {
+              console.error("Workspace reset error", err);
+              message.error("Failed to reset workspace");
+            }
+          },
+        });
+      },
+    });
+  };
+
+  const workspaceMenuItems = [
+    {
+      key: "reset_workspace",
+      label: "Reset Workspace",
+      icon: <DeleteOutlined />,
+      danger: true,
+    },
+  ];
+
   const handleUnmountProject = async (folderKey) => {
     const mountedFolder = folders.find((f) => f.key === folderKey);
     if (!mountedFolder) return;
@@ -1438,6 +1516,19 @@ function FilesManager() {
           >
             Mount Project
           </Button>
+          <Dropdown
+            menu={{
+              items: workspaceMenuItems,
+              onClick: ({ key }) => {
+                if (key === "reset_workspace") {
+                  handleResetWorkspace();
+                }
+              },
+            }}
+            trigger={["click"]}
+          >
+            <Button icon={<MoreOutlined />} title="More file actions" />
+          </Dropdown>
         </div>
 
         {/* Content Area */}

server_api/auth/router.py

@@ -22,6 +22,7 @@
 router = APIRouter()
 
 oauth2_scheme = OAuth2PasswordBearer(tokenUrl="token", auto_error=False)
+IGNORED_SYSTEM_FILENAMES = {".ds_store", "thumbs.db"}
 
 
 def _format_size(size_bytes: int) -> str:
@@ -34,6 +35,10 @@ def _format_size(size_bytes: int) -> str:
     return f"{size_bytes / (1024 * 1024 * 1024):.1f}GB"
 
 
+def _is_ignored_system_file(name: Optional[str]) -> bool:
+    return str(name or "").strip().lower() in IGNORED_SYSTEM_FILENAMES
+
+
 def _ensure_unique_name(
     db: Session, user_id: int, parent_path: str, base_name: str
 ) -> str:
@@ -183,7 +188,9 @@ def get_files(
     current_user: models.User = Depends(get_current_user),
     db: Session = Depends(database.get_db),
 ):
-    return current_user.files
+    return [
+        file for file in current_user.files if not _is_ignored_system_file(file.name)
+    ]
 
 
 @router.get("/files/preview/{file_id}")
@@ -272,6 +279,11 @@ def upload_file(
     current_user: models.User = Depends(get_current_user),
     db: Session = Depends(database.get_db),
 ):
+    if _is_ignored_system_file(file.filename):
+        raise HTTPException(
+            status_code=400, detail="System metadata files are ignored"
+        )
+
     # Create uploads directory if not exists
     upload_dir = f"uploads/{current_user.id}"
     os.makedirs(upload_dir, exist_ok=True)
@@ -461,6 +473,8 @@ def mount_directory(
             mounted_folders += 1
 
         for filename in filenames:
+            if _is_ignored_system_file(filename):
+                continue
             abs_file = os.path.join(current_dir, filename)
             if not os.path.isfile(abs_file):
                 continue
@@ -549,6 +563,49 @@ def unmount_project(
     return {"message": "Project unmounted"}
 
 
+@router.delete("/files/workspace")
+def reset_workspace(
+    current_user: models.User = Depends(get_current_user),
+    db: Session = Depends(database.get_db),
+):
+    root_nodes = (
+        db.query(models.File)
+        .filter(models.File.user_id == current_user.id, models.File.path == "root")
+        .all()
+    )
+    total_rows = (
+        db.query(models.File).filter(models.File.user_id == current_user.id).count()
+    )
+    mounted_root_count = 0
+
+    for node in root_nodes:
+        delete_disk_files = True
+        if node.physical_path and not _is_managed_upload_path(
+            current_user.id, node.physical_path
+        ):
+            mounted_root_count += 1
+            delete_disk_files = False
+
+        _delete_file_tree(
+            db,
+            current_user.id,
+            node,
+            delete_disk_files=delete_disk_files,
+        )
+
+    uploads_root = os.path.abspath(os.path.join("uploads", str(current_user.id)))
+    if os.path.isdir(uploads_root):
+        shutil.rmtree(uploads_root, ignore_errors=True)
+    os.makedirs(uploads_root, exist_ok=True)
+
+    db.commit()
+    return {
+        "message": "Workspace reset",
+        "deleted_count": total_rows,
+        "mounted_root_count": mounted_root_count,
+    }
+
+
 @router.delete("/files/{file_id}")
 def delete_file(
     file_id: int,

tests/test_file_workspace_routes.py

@@ -0,0 +1,148 @@
+import pathlib
+import shutil
+import tempfile
+import unittest
+
+from fastapi.testclient import TestClient
+from sqlalchemy import create_engine
+from sqlalchemy.orm import sessionmaker
+
+from server_api.auth import database as auth_database
+from server_api.auth import models
+from server_api.main import app as server_api_app
+
+
+class FileWorkspaceRouteTests(unittest.TestCase):
+    def setUp(self):
+        self.temp_dir = tempfile.TemporaryDirectory()
+        self.db_path = pathlib.Path(self.temp_dir.name) / "auth-test.db"
+        self.engine = create_engine(
+            f"sqlite:///{self.db_path}", connect_args={"check_same_thread": False}
+        )
+        self.SessionLocal = sessionmaker(
+            autocommit=False, autoflush=False, bind=self.engine
+        )
+        models.Base.metadata.create_all(bind=self.engine)
+
+        def override_get_db():
+            db = self.SessionLocal()
+            try:
+                yield db
+            finally:
+                db.close()
+
+        server_api_app.dependency_overrides[auth_database.get_db] = override_get_db
+        self.client = TestClient(server_api_app)
+
+        with self.SessionLocal() as db:
+            guest = models.User(
+                username="guest",
+                email=None,
+                hashed_password="guest",
+            )
+            db.add(guest)
+            db.commit()
+            db.refresh(guest)
+            self.user_id = guest.id
+
+        self.uploads_root = pathlib.Path("uploads") / str(self.user_id)
+        if self.uploads_root.exists():
+            shutil.rmtree(self.uploads_root)
+        self.uploads_root.mkdir(parents=True, exist_ok=True)
+
+    def tearDown(self):
+        server_api_app.dependency_overrides.clear()
+        if self.uploads_root.exists():
+            shutil.rmtree(self.uploads_root, ignore_errors=True)
+        self.engine.dispose()
+        self.temp_dir.cleanup()
+
+    def _create_file(
+        self,
+        *,
+        name,
+        path="root",
+        is_folder=False,
+        physical_path=None,
+        size="1B",
+        file_type="text/plain",
+    ):
+        with self.SessionLocal() as db:
+            node = models.File(
+                user_id=self.user_id,
+                name=name,
+                path=path,
+                is_folder=is_folder,
+                physical_path=physical_path,
+                size=size,
+                type=file_type,
+            )
+            db.add(node)
+            db.commit()
+            db.refresh(node)
+            return node.id
+
+    def test_mount_directory_skips_os_metadata_files(self):
+        mount_root = pathlib.Path(self.temp_dir.name) / "project"
+        mount_root.mkdir()
+        (mount_root / ".DS_Store").write_text("junk", encoding="utf-8")
+        (mount_root / "volume.tif").write_text("data", encoding="utf-8")
+
+        response = self.client.post(
+            "/files/mount",
+            json={
+                "directory_path": str(mount_root),
+                "destination_path": "root",
+            },
+        )
+
+        self.assertEqual(response.status_code, 200)
+        self.assertEqual(response.json()["mounted_files"], 1)
+
+        files_response = self.client.get("/files")
+        self.assertEqual(files_response.status_code, 200)
+        names = {item["name"] for item in files_response.json()}
+        self.assertIn("project", names)
+        self.assertIn("volume.tif", names)
+        self.assertNotIn(".DS_Store", names)
+
+    def test_reset_workspace_preserves_mounted_sources_and_clears_uploads(self):
+        mount_root = pathlib.Path(self.temp_dir.name) / "mounted-project"
+        mount_root.mkdir()
+        mounted_file = mount_root / "volume.tif"
+        mounted_file.write_text("data", encoding="utf-8")
+
+        mount_response = self.client.post(
+            "/files/mount",
+            json={
+                "directory_path": str(mount_root),
+                "destination_path": "root",
+            },
+        )
+        self.assertEqual(mount_response.status_code, 200)
+
+        upload_file = self.uploads_root / "uploaded.tif"
+        upload_file.write_text("upload", encoding="utf-8")
+        self._create_file(
+            name="uploaded.tif",
+            physical_path=str(upload_file),
+            size="6B",
+        )
+
+        response = self.client.delete("/files/workspace")
+
+        self.assertEqual(response.status_code, 200)
+        self.assertGreaterEqual(response.json()["deleted_count"], 3)
+        self.assertEqual(response.json()["mounted_root_count"], 1)
+        self.assertTrue(mount_root.exists())
+        self.assertTrue(mounted_file.exists())
+        self.assertFalse(upload_file.exists())
+        self.assertTrue(self.uploads_root.exists())
+
+        files_response = self.client.get("/files")
+        self.assertEqual(files_response.status_code, 200)
+        self.assertEqual(files_response.json(), [])
+
+
+if __name__ == "__main__":
+    unittest.main()