Stop the Windows liveness check from killing R sessions

ClaudeR 0.13.2. cleanup_stale_discovery_files() probed a recorded pid
with tools::pskill(pid, signal = 0). On Unix that maps to kill(pid, 0)
and is a safe existence test, which is what the comment claimed. On
Windows it is not: ?tools::pskill states only SIGINT and SIGTERM exist
there and that pskill always uses TerminateProcess. The probe therefore
terminated the session it was asking about, and because the kill
succeeded the file was judged live and left behind, so agents were then
routed to a dead port. It ran on every Start Server, so a Windows user
with two RStudio sessions killed one by starting the other.

New pid_is_alive() never signals on Windows; it asks tasklist, which
ships with the OS and needs no extra package. Unix keeps kill(pid, 0).

Also: write_discovery_file() overwrote the discovery file of a
different live session registered under the same name, leaving agents
with a stale port and a token that no longer matched. Port reuse was
already reported loudly; this was silent. It now warns and names the
conflicting pid and port.

R CMD check: Status OK.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>

Author: IMNMV

DESCRIPTION

@@ -1,6 +1,6 @@
 Package: ClaudeR
 Title: R Integration for Claude AI
-Version: 0.13.1
+Version: 0.13.2
 Authors@R: person("Nykko", "Vitali", email = "nykvt@icloud.com", role = c("aut", "cre"))
 Description: Connects RStudio with Claude AI to enable interactive coding sessions.
 License: MIT + file LICENSE

R/ui.R

@@ -65,6 +65,19 @@ write_discovery_file <- function(session_name, port, token) {
     started_at = format(Sys.time(), "%Y-%m-%dT%H:%M:%S")
   )
   f <- file.path(d, paste0(session_name, ".json"))
+  # Two live sessions sharing a name would silently clobber each other's
+  # discovery file, and agents would then be routed to one of them holding the
+  # other's token. Port reuse is already caught loudly; this was not.
+  if (file.exists(f)) {
+    other <- tryCatch(jsonlite::fromJSON(f), error = function(e) NULL)
+    if (!is.null(other) && !identical(as.integer(other$pid), Sys.getpid()) &&
+        pid_is_alive(other$pid)) {
+      warning(sprintf(paste0("Another live R session is already registered as '%s' ",
+                             "(pid %s, port %s). Give this session a different name, ",
+                             "or agents may be routed to the wrong one."),
+                      session_name, other$pid, other$port), call. = FALSE)
+    }
+  }
   jsonlite::write_json(info, f, auto_unbox = TRUE, pretty = TRUE)
   try(Sys.chmod(f, mode = "0600"), silent = TRUE)
 }
@@ -74,16 +87,38 @@ remove_discovery_file <- function(session_name) {
   if (file.exists(f)) file.remove(f)
 }
 
+# Is a process alive? Must never kill it.
+#
+# tools::pskill(pid, signal = 0) is the usual idiom, and it is safe on Unix
+# where it maps to kill(pid, 0). On Windows it is NOT: ?tools::pskill states
+# that only SIGINT and SIGTERM exist there and that pskill "will always use the
+# Windows system call TerminateProcess". Using it as a liveness probe therefore
+# terminated the very session it was asking about, and returned TRUE for the
+# kill, so the discovery file was then judged live and left behind.
+pid_is_alive <- function(pid) {
+  pid <- suppressWarnings(as.integer(pid))
+  if (is.na(pid) || pid <= 0) return(FALSE)
+  if (.Platform$OS.type == "windows") {
+    # tasklist ships with Windows, so this needs no extra package.
+    out <- tryCatch(
+      suppressWarnings(system2("tasklist",
+                               c("/FI", shQuote(sprintf("PID eq %d", pid)), "/NH"),
+                               stdout = TRUE, stderr = NULL)),
+      error = function(e) character(0)
+    )
+    return(any(grepl(paste0("\\b", pid, "\\b"), out)))
+  }
+  isTRUE(tryCatch(tools::pskill(pid, signal = 0), error = function(e) FALSE))
+}
+
 cleanup_stale_discovery_files <- function() {
   d <- discovery_dir()
   if (!dir.exists(d)) return(invisible(NULL))
   files <- list.files(d, pattern = "\\.json$", full.names = TRUE)
   for (f in files) {
     tryCatch({
       info <- jsonlite::fromJSON(f)
-      # signal = 0 checks if PID exists without killing it
-      pid_alive <- tools::pskill(info$pid, signal = 0)
-      if (!isTRUE(pid_alive)) file.remove(f)
+      if (!pid_is_alive(info$pid)) file.remove(f)
     }, error = function(e) {
       # Corrupted file, remove it
       file.remove(f)

README.md

@@ -50,6 +50,8 @@ claudeAddin()
 <details>
 <summary><b>Recent Updates</b> (click to expand)</summary>
 
+- **Windows session-liveness fix (R 0.13.2).** Checking whether a recorded R session was still alive used `tools::pskill(pid, signal = 0)`. That is the standard idiom on Unix, but on Windows `pskill` always calls `TerminateProcess` regardless of signal, so the check killed the session it was asking about, then reported it as alive and left the stale discovery file in place. Starting a server could therefore terminate another RStudio session and leave agents routed to a dead port. Liveness is now probed without signalling. Separately, registering a session whose name is already held by a different live session now warns instead of silently overwriting its discovery file, which had left agents holding the wrong port and token.
+
 - **Unified console logging (R 0.13.0).** The session log recorded what the agent ran, but not what you ran, so asking an agent to explain an error you hit in the console meant re-running the work through it. Tick "Also log my own console commands" under Logging and your console activity joins the same file, tagged by who ran what: the command, its printed result, and any warnings, messages, or errors. "Read the last 100 lines of the log" is now enough for an agent to see both sides of the session. Off by default; toggle it in the addin or call `start_console_logging()` / `stop_console_logging()`.
 
 - **Editor tools fixed, plus approve-before-apply edits (R 0.12.5 / clauder-mcp 0.14.4).** From two user reports. `modify_code_section` and `insert_text` now save to disk by default and report `saved_to_disk`, so an agent no longer believes it wrote a file when the change sat unsaved in the buffer. Bounded replacements may change the line count (the old equality constraint is gone). Both tools accept a `path` to target a specific file, open and focus it, and refuse to edit a different document instead of failing silently. `get_active_document` now reports the path, the document id, and whether the buffer differs from disk, so buffer state and file state stop being confused for each other. New `suggest_edit` tool: the agent proposes a change and waits for the user to approve it, using `rstudioapi::showEditSuggestion()` when the installed rstudioapi provides it, and otherwise staging the edit unsaved so the user accepts by saving or rejects with undo.