feat: implement idle session pruning in TaskManager

- Add `session_idle_timeout` to `TaskManager` (default 60s).
- Implement `prune_sessions` to automatically close and remove idle sessions.
- Add test case to verify session cleanup after inactivity.

Author: randy3k

R/languageserver.R

@@ -55,7 +55,7 @@ LanguageServer <- R6::R6Class("LanguageServer",
 
             self$parse_task_manager <- TaskManager$new(
                 "parse",
-                use_session = TRUE, process_recent_first = TRUE,
+                use_session = TRUE, process_recent_first = TRUE
             )
             self$diagnostics_task_manager <- TaskManager$new(
                 "diagnostics",

R/task.R

@@ -49,7 +49,15 @@ Task <- R6::R6Class("Task",
                         return(TRUE)
                     }
                 }
-                return(private$session$get_state() == "finished")
+                state <- private$session$get_state()
+                if (identical(state, "finished")) {
+                    if (!is.null(private$error)) {
+                        err <- simpleError("Session finished unexpectedly while task was running")
+                        private$error(err)
+                    }
+                    return(TRUE)
+                }
+                return(FALSE)
             }
 
             if (is.null(private$process)) {
@@ -98,6 +106,7 @@ TaskManager <- R6::R6Class("TaskManager",
         sessions = NULL,
         process_recent_first = NULL,
         max_running_tasks = NULL,
+        session_idle_timeout = NULL,
         find_or_create_session = function() {
             if (!isTRUE(private$use_session)) {
                 return(NULL)
@@ -127,20 +136,41 @@ TaskManager <- R6::R6Class("TaskManager",
             }
 
             NULL
+        },
+        prune_sessions = function() {
+            for (i in rev(seq_along(private$sessions))) {
+                session <- private$sessions[[i]]
+                state <- session$get_state()
+                if (state == "finished") {
+                    private$sessions[[i]] <- NULL
+                } else if (state == "idle") {
+                    idle_start <- attr(session, "idle_start")
+                    if (is.null(idle_start)) {
+                        attr(session, "idle_start") <- Sys.time()
+                    } else if (as.numeric(difftime(Sys.time(), idle_start, units = "secs")) > private$session_idle_timeout) {
+                        session$close()
+                        private$sessions[[i]] <- NULL
+                    }
+                } else {
+                    attr(session, "idle_start") <- NULL
+                }
+            }
         }
     ),
     public = list(
         initialize = function(name,
                               use_session = FALSE,
                               process_recent_first = FALSE,
                               cpu_load = 0.5,
-                              max_running_tasks = 8) {
+                              max_running_tasks = 8,
+                              session_idle_timeout = 60) {
             private$pending_tasks <- collections::ordered_dict()
             private$running_tasks <- collections::ordered_dict()
             private$name <- name
             private$use_session <- use_session
             private$process_recent_first <- process_recent_first
 
+            private$session_idle_timeout <- session_idle_timeout
             cpus <- min(parallel::detectCores())
             max_running_tasks <- min(cpus, max_running_tasks)
             private$max_running_tasks <- max(min(max_running_tasks, round(cpus * cpu_load)), 1)
@@ -167,11 +197,6 @@ TaskManager <- R6::R6Class("TaskManager",
                 pending_ids <- pending_ids[seq_len(n)]
             }
 
-            if (isTRUE(private$use_session)) {
-                states <- vapply(private$sessions, function(s) s$get_state(), character(1))
-                private$sessions <- private$sessions[states != "finished"]
-            }
-
             for (id in pending_ids) {
                 task <- private$pending_tasks$get(id)
                 if (Sys.time() - task$time >= task$delay) {
@@ -205,6 +230,9 @@ TaskManager <- R6::R6Class("TaskManager",
                     running_tasks$remove(key)
                 }
             }
+            if (isTRUE(private$use_session)) {
+                private$prune_sessions()
+            }
         },
         stop = function() {
             for (id in private$running_tasks$keys()) {

tests/testthat/test-task.R

@@ -17,7 +17,7 @@ for (covr in c("false", "true")) {
             tm$add_task("t1", task)
 
             tm$run_tasks()
-            
+
             # Wait for the task to finish
             for (i in 1:10) {
                 Sys.sleep(0.5)
@@ -100,3 +100,44 @@ for (covr in c("false", "true")) {
         })
     })
 }
+
+test_that("TaskManager prunes idle sessions", {
+    skip_on_cran()
+
+    # Initialize TaskManager with a short timeout
+    tm <- TaskManager$new("test", use_session = TRUE, session_idle_timeout = 2)
+
+    # Create a dummy task
+    task <- create_task(function() 1, list())
+    tm$add_task("1", task)
+
+    # Run the task
+    tm$run_tasks()
+
+    # Wait for task completion
+    start_time <- Sys.time()
+    while (length(tm$.__enclos_env__$private$running_tasks$keys()) > 0 ||
+        length(tm$.__enclos_env__$private$pending_tasks$keys()) > 0) {
+        tm$check_tasks()
+        tm$run_tasks()
+        if (Sys.time() - start_time > 10) stop("Task timed out")
+        Sys.sleep(0.1)
+    }
+
+    # Verify session is idle
+    sessions <- tm$.__enclos_env__$private$sessions
+    expect_length(sessions, 1)
+    expect_equal(sessions[[1]]$get_state(), "idle")
+
+    # Wait for timeout
+    Sys.sleep(5)
+
+    # Trigger pruning
+    tm$check_tasks()
+
+    # Verify session is removed
+    sessions <- tm$.__enclos_env__$private$sessions
+    expect_length(sessions, 0)
+
+    tm$stop()
+})