Upload folder using huggingface_hub

Generated/README.md

@@ -1,3 +1,3 @@
-# Generated
+# view_session
 
 Placeholder to ensure this directory is tracked.

app.py

@@ -21,7 +21,7 @@ def ensure_root_directories(main_workspace: Path) -> None:
         main_workspace / "static" / "css",
         main_workspace / "static" / "js",
         main_workspace / "static" / "images",
-        main_workspace / "view_session",
+    main_workspace / "view_session",
     ]
 
     for d in required:
@@ -51,6 +51,51 @@ def ensure_root_directories(main_workspace: Path) -> None:
         except Exception as e:
             print(f"⚠️  Warning: could not ensure {d}: {e}")
 
+def ensure_view_session_points_to_generated(main_workspace: Path) -> None:
+    """Ensure root-level view_session is a symlink to Generated (so UI views read from Generated)."""
+    vs = main_workspace / "view_session"
+    gen = main_workspace / "Generated"
+    try:
+        gen.mkdir(parents=True, exist_ok=True)
+        if vs.exists() or vs.is_symlink():
+            try:
+                if vs.is_symlink() and vs.resolve() == gen.resolve():
+                    print(f"🔗 Root symlink already set: {vs} -> {gen}")
+                    return
+            except Exception:
+                pass
+            if vs.is_symlink():
+                vs.unlink()
+            elif vs.is_dir():
+                # migrate contents into Generated
+                for item in vs.iterdir():
+                    dest = gen / item.name
+                    try:
+                        if item.is_dir():
+                            if dest.exists():
+                                for sub in item.iterdir():
+                                    sub.rename(dest / sub.name)
+                                item.rmdir()
+                            else:
+                                item.rename(dest)
+                        else:
+                            if dest.exists():
+                                dest.unlink()
+                            item.rename(dest)
+                    except Exception as me:
+                        print(f"⚠️  Root migration warning for {item}: {me}")
+                try:
+                    vs.rmdir()
+                except Exception:
+                    pass
+            else:
+                vs.unlink()
+        # create symlink view_session -> Generated
+        vs.symlink_to(gen, target_is_directory=True)
+        print(f"🔗 Root linked {vs} -> {gen}")
+    except Exception as e:
+        print(f"⚠️  Could not link root view_session to Generated: {e}")
+
 def create_symlinks_to_real_folders(cache_dir):
     """Create symbolic links in cache directory to real folders in main workspace."""
     # Use the directory containing this script as root workspace
@@ -63,7 +108,8 @@ def create_symlinks_to_real_folders(cache_dir):
     
     for folder_name in folders_to_link:
         # Real folder path in main workspace
-        real_folder = main_workspace / folder_name
+        # Map view_session to Generated so the UI reads sessions from Generated
+        real_folder = (main_workspace / "Generated") if folder_name == "view_session" else (main_workspace / folder_name)
         # Symbolic link path in cache
         link_path = cache_dir / folder_name
         
@@ -71,19 +117,49 @@ def create_symlinks_to_real_folders(cache_dir):
             # Ensure real folder exists (defensive)
             real_folder.mkdir(parents=True, exist_ok=True)
 
-            # Remove existing file/folder/link if it exists
+            # If an entry exists at the link path, handle safely
             if link_path.exists() or link_path.is_symlink():
                 if link_path.is_symlink():
+                    try:
+                        # If already correct, keep it
+                        if link_path.resolve() == real_folder.resolve():
+                            print(f"✅ Symlink already set: {link_path} -> {real_folder}")
+                            continue
+                    except Exception:
+                        pass
                     link_path.unlink()
                 elif link_path.is_dir():
-                    shutil.rmtree(link_path)
+                    # Migrate existing contents to the real folder before replacing
+                    for item in link_path.iterdir():
+                        dest = real_folder / item.name
+                        try:
+                            if item.is_dir():
+                                if dest.exists():
+                                    # Merge directories
+                                    for sub in item.iterdir():
+                                        sub.rename(dest / sub.name)
+                                    item.rmdir()
+                                else:
+                                    item.rename(dest)
+                            else:
+                                if dest.exists():
+                                    dest.unlink()
+                                item.rename(dest)
+                        except Exception as me:
+                            print(f"⚠️  Migration warning for {item}: {me}")
+                    # Remove the now-empty directory
+                    try:
+                        link_path.rmdir()
+                    except Exception:
+                        pass
                 else:
+                    # Regular file – remove so we can place a symlink
                     link_path.unlink()
-            
+
             # Create symbolic link
             link_path.symlink_to(real_folder, target_is_directory=True)
             print(f"✅ Created symlink: {link_path} -> {real_folder}")
-            
+
         except Exception as e:
             print(f"⚠️  Warning: Could not create symlink for {folder_name}: {e}")
             # Fallback: create empty directory
@@ -93,6 +169,32 @@ def create_symlinks_to_real_folders(cache_dir):
     print("🎯 All symbolic links are ready!")
     return True
 
+def verify_cache_symlink(cache_dir: Path, name: str, root_dir: Path) -> bool:
+    """Verify a specific symlink in cache points to the corresponding root dir and is writable."""
+    link = cache_dir / name
+    target = root_dir / name
+    try:
+        if not link.exists():
+            print(f"❌ Missing link/path in cache: {link}")
+            return False
+        if not link.is_symlink():
+            print(f"⚠️  Cache path is not a symlink (still usable): {link}")
+        else:
+            if link.resolve() != target.resolve():
+                print(f"⚠️  Symlink target mismatch: {link.resolve()} != {target}")
+            else:
+                print(f"🔗 Verified symlink: {link} -> {target}")
+        # Write/read test
+        tf = link / ".__verify__"
+        tf.write_text("ok")
+        assert (target / ".__verify__").read_text() == "ok"
+        tf.unlink(missing_ok=True)
+        print(f"✅ Write/Read OK via cache link: {link}")
+        return True
+    except Exception as e:
+        print(f"❌ Verification failed for {link}: {e}")
+        return False
+
 def modify_byteplus_for_directories(cache_dir):
     """Modify the BytePlus app to ensure proper directory handling."""
     app_file = cache_dir / "app.py"
@@ -383,7 +485,10 @@ if __name__ == "__main__":
     print(f"📁 Cache directory: {cache_dir}")
 
     # Ensure root directories exist first (as requested)
-    ensure_root_directories(Path(__file__).parent.resolve())
+    root = Path(__file__).parent.resolve()
+    ensure_root_directories(root)
+    # Ensure view_session at root points to Generated for History/View/ZIP
+    ensure_view_session_points_to_generated(root)
     
     # Download the space
     if download_space(cache_dir):