Implement bug fixes for file handling and JupyterLab checks

Added multiple bug fixes to handle file size limits, exclude paths correctly, and ensure JupyterLab is not running during restore.

jupyter-devdata-sync.py

@@ -1,7 +1,7 @@
 #!/usr/bin/env python3
 from __future__ import annotations
 
-import os, shutil, tempfile, time
+import os, shutil, socket, sys, tempfile, time
 from pathlib import Path
 
 HF_TOKEN = os.environ.get("HF_TOKEN", "").strip()
@@ -10,6 +10,12 @@ DATASET_NAME = os.environ.get("DEVDATA_DATASET_NAME", "").strip() or "huggingcla
 BACKUP_DATASET_NAME = os.environ.get("BACKUP_DATASET_NAME", "").strip() or os.environ.get("BACKUP_DATASET", "").strip() or "huggingclaw-backup"
 JUPYTER_ROOT = Path(os.environ.get("JUPYTER_ROOT_DIR", "/home/node")).resolve()
 INTERVAL = int((os.environ.get("DEVDATA_SYNC_INTERVAL", "").strip() or "180"))
+# BUG FIX #5: Respect max file size so giant files don't stall uploads.
+# Matches the 50 MB ceiling in openclaw-sync.py; override with DEVDATA_MAX_FILE_BYTES.
+MAX_FILE_SIZE_BYTES = int(
+    (os.environ.get("DEVDATA_MAX_FILE_BYTES", "").strip() or str(50 * 1024 * 1024))
+)
+
 def is_true(value):
     return str(value).strip().lower() in {"1", "true", "yes", "on"}
 
@@ -26,12 +32,17 @@ def classify_error(exc: Exception) -> str:
         return "safety-scan"
     return "general"
 
+# BUG FIX #4: ".local/share/Trash" in the original EXCLUDE set was a
+# multi-component path string that was never matched because parts-based
+# lookup compares individual directory names.  Added "Trash" as a standalone
+# component so any path with a "Trash" segment (e.g. .local/share/Trash/*)
+# is correctly skipped during snapshot and restore.
 EXCLUDE = {
     ".cache",
     "node_modules",
     ".npm",
     ".yarn",
-    ".local/share/Trash",
+    "Trash",            # BUG FIX #4: covers .local/share/Trash (was ".local/share/Trash" — never matched)
     ".ipynb_checkpoints",
     ".openclaw",
     "app",
@@ -85,13 +96,38 @@ def snapshot(src: Path, dst: Path):
         if p.is_dir():
             target.mkdir(parents=True, exist_ok=True)
         elif p.is_file():
+            # BUG FIX #5: Skip files that exceed the size limit.
+            try:
+                if p.stat().st_size > MAX_FILE_SIZE_BYTES:
+                    continue
+            except OSError:
+                continue
             target.parent.mkdir(parents=True, exist_ok=True)
             try:
                 shutil.copy2(p, target)
             except OSError:
                 pass
 
-def restore_once(api: HfApi, rid: str):
+def is_jupyter_running(port: int = 8888) -> bool:
+    """Return True if JupyterLab is already listening on *port*.
+
+    BUG FIX #2 (safety net): restore_once() must never run while JupyterLab
+    is active.  Overwriting files under JUPYTER_ROOT (runtime/ sockets, lab/
+    settings, kernel connection files) while JupyterLab is live corrupts its
+    state and causes it to exit within seconds.
+
+    The primary guard is the --restore / sync separation introduced in
+    BUG FIX #3, but this TCP probe stays as a hard backstop for any future
+    code path that might call restore_once() unexpectedly.
+    """
+    try:
+        with socket.create_connection(("127.0.0.1", port), timeout=2):
+            return True
+    except OSError:
+        return False
+
+def restore_once(api, rid: str):
+    from huggingface_hub.errors import RepositoryNotFoundError
     tmp = Path(tempfile.mkdtemp(prefix="devdata-restore-"))
     try:
         snapshot_download(repo_id=rid, repo_type="dataset", local_dir=str(tmp), local_dir_use_symlinks=False, token=HF_TOKEN)
@@ -99,6 +135,8 @@ def restore_once(api: HfApi, rid: str):
             rel = p.relative_to(tmp)
             if should_skip(rel):
                 continue
+            if str(rel) == ".gitattributes":
+                continue
             target = JUPYTER_ROOT / rel
             if p.is_dir():
                 target.mkdir(parents=True, exist_ok=True)
@@ -118,15 +156,48 @@ def restore_once(api: HfApi, rid: str):
     finally:
         shutil.rmtree(tmp, ignore_errors=True)
 
-def sync_loop(api: HfApi, rid: str):
+def prune_remote_deleted_files(api, rid: str, snapshot_dir: Path) -> None:
+    """BUG FIX #6: Delete from the HF dataset any files the user deleted
+    locally.  Without this, deleted files re-appear on the next Space restart
+    because restore_once() copies everything in the dataset back to disk.
+    Mirrors the prune_remote_deleted_files() logic in openclaw-sync.py.
+    """
+    try:
+        local_files = {
+            p.relative_to(snapshot_dir).as_posix()
+            for p in snapshot_dir.rglob("*")
+            if p.is_file()
+        }
+        remote_files = list(api.list_repo_files(repo_id=rid, repo_type="dataset"))
+        stale = [f for f in remote_files if f not in local_files and f != ".gitattributes"]
+        if stale:
+            api.delete_files(
+                delete_patterns=stale,
+                repo_id=rid,
+                repo_type="dataset",
+                commit_message=f"DevData prune {len(stale)} deleted file(s) {time.strftime('%Y-%m-%dT%H:%M:%SZ', time.gmtime())}",
+            )
+            print(f"DevData pruned {len(stale)} deleted file(s) from {rid}")
+    except Exception as exc:
+        kind = classify_error(exc)
+        print(f"DevData prune warning [{kind}]: {exc}")
+
+def sync_loop(api, rid: str):
     while True:
         tmp = Path(tempfile.mkdtemp(prefix="devdata-snap-"))
         try:
             snapshot(JUPYTER_ROOT, tmp)
-            upload_folder(folder_path=str(tmp), repo_id=rid, repo_type="dataset", token=HF_TOKEN,
-                          commit_message=f"DevData sync {time.strftime('%Y-%m-%dT%H:%M:%SZ', time.gmtime())}",
-                          ignore_patterns=[".git/*", ".git"])
+            upload_folder(
+                folder_path=str(tmp),
+                repo_id=rid,
+                repo_type="dataset",
+                token=HF_TOKEN,
+                commit_message=f"DevData sync {time.strftime('%Y-%m-%dT%H:%M:%SZ', time.gmtime())}",
+                ignore_patterns=[".git/*", ".git"],
+            )
             print(f"DevData synced to {rid}")
+            # BUG FIX #6: Prune files deleted locally so they don't reappear on restore.
+            prune_remote_deleted_files(api, rid, tmp)
         except Exception as exc:
             kind = classify_error(exc)
             print(f"DevData sync warning [{kind}]: {exc}")
@@ -134,10 +205,12 @@ def sync_loop(api: HfApi, rid: str):
             shutil.rmtree(tmp, ignore_errors=True)
         time.sleep(INTERVAL)
 
+
 if __name__ == "__main__":
     if not enabled():
         print("DevData sync disabled.")
         raise SystemExit(0)
+
     from huggingface_hub import HfApi, upload_folder, snapshot_download
     from huggingface_hub.errors import RepositoryNotFoundError
 
@@ -147,6 +220,36 @@ if __name__ == "__main__":
         api.repo_info(repo_id=rid, repo_type="dataset")
     except RepositoryNotFoundError:
         api.create_repo(repo_id=rid, repo_type="dataset", private=True)
+
+    # ── BUG FIX #3: Restore must happen BEFORE JupyterLab starts ──────────
+    # The original code always called restore_once() here, but start.sh starts
+    # JupyterLab long before the gateway is ready and this script is launched.
+    # That made restore_once() ALWAYS run while JupyterLab was live, which
+    # overwrote its runtime/ sockets and settings → JupyterLab died.
+    #
+    # Fix: start.sh now calls  `python3 jupyter-devdata-sync.py --restore`
+    # BEFORE starting JupyterLab.  That --restore invocation does the restore
+    # and exits.  This background invocation (no --restore flag) skips straight
+    # to sync_loop so it never touches files while JupyterLab is running.
+    #
+    # BUG FIX #2 (safety net): If JupyterLab is somehow already running when
+    # this code path is reached, abort restore to avoid corrupting its state.
+    if "--restore" in sys.argv:
+        # Synchronous restore mode — called by start.sh before JupyterLab.
+        validate_jupyter_paths()
+        restore_once(api, rid)
+        raise SystemExit(0)
+
+    # Normal background sync mode — no restore; go straight to upload loop.
     validate_jupyter_paths()
-    restore_once(api, rid)
+    if is_jupyter_running():
+        print("DevData: background sync started (JupyterLab is live, restore already done by --restore).")
+    else:
+        # Fallback: JupyterLab not detected.  Should not normally happen
+        # because start.sh calls --restore before starting JupyterLab and then
+        # waits for the gateway before launching this background process.
+        # Log a warning and proceed to sync; do NOT restore to avoid racing
+        # with a JupyterLab that may be in the middle of starting up.
+        print("DevData: WARNING — JupyterLab not detected on port 8888. Skipping restore to be safe; starting sync loop.")
+
     sync_loop(api, rid)