Arm the console-log callback before anything that can fail (addin path)

ClaudeR 0.14.2. From a user report with screenshot: on 0.14.1 the addin
checkbox "Also log my own console commands" logged nothing, while the
same feature started from the console worked.

globalCallingHandlers() may only be called with an empty handler stack.
The addin checkbox is handled inside a Shiny observer, where handlers
are on the stack, so it errors with "should not be called with handlers
on the stack". 0.14.1 had moved that call to the front of
start_console_logging(), so the error aborted the function before
addTaskCallback() ran and the user's commands were never recorded. (It
also fails inside task callbacks, later() callbacks and tryCatch, so it
cannot be deferred or guarded; only a bare top-level call works.)

Now: the task callback is registered first and unconditionally, the
sink and options(error=) follow, and globalCallingHandlers() is
attempted last and only when sys.nframe() shows a bare top-level call.
Without it, warnings are read from last.warning after each command
(reported only when changed, since it lingers); message() output is not
captured from the addin path and the startup message says so.
stop_console_logging() likewise removes the handlers only at top level;
otherwise they stay installed as no-ops (console_note_condition checks
the active flag). start also re-arms if the callback has gone missing.

Verified: start/stop from inside withCallingHandlers register/remove the
callback without error and log commands, printed output and warnings;
bare top-level start installs the handlers and captures message().
R CMD check: Status OK.

Co-Authored-By: Claude Fable 5.1 <noreply@anthropic.com>

Author: IMNMV

DESCRIPTION

@@ -1,6 +1,6 @@
 Package: ClaudeR
 Title: R Integration for Claude AI
-Version: 0.14.1
+Version: 0.14.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/console_log.R

@@ -5,7 +5,15 @@
 #   addTaskCallback        the expression the user typed, and its visible value
 #   globalCallingHandlers  warnings and messages (they go to stderr, so a sink
 #                          cannot see them; R >= 4.0 lets us observe without
-#                          suppressing)
+#                          suppressing). CONSTRAINT: it can only be called with
+#                          an empty handler stack, i.e. from a bare top-level
+#                          console call. Inside a Shiny observer (the addin
+#                          checkbox), a task callback, a later() callback, or
+#                          tryCatch() it errors "should not be called with
+#                          handlers on the stack". So it is attempted only when
+#                          sys.nframe() says we are at top level; otherwise
+#                          warnings are read from last.warning after each
+#                          command instead, and message() output is not captured.
 #   options(error=)        uncaught errors
 #   sink(split = TRUE)     everything printed as a side effect: cat(), progress
 #                          output, print() called inside a function. The task
@@ -43,6 +51,7 @@ console_trim <- function(x, max_lines = 40L) {
 }
 
 console_note_condition <- function(kind, msg) {
+  if (!isTRUE(.console_state$active)) return(invisible(NULL))
   msg <- trimws(paste(msg, collapse = " "))
   if (!nzchar(msg)) return(invisible(NULL))
   .console_state$pending <- c(.console_state$pending,
@@ -133,6 +142,17 @@ console_task_callback <- function(expr, value, ok, visible) {
       if (length(out)) lines <- paste0("#> ", console_trim(out))
     }
     if (!isTRUE(ok)) lines <- c(lines, "#> error: command did not complete")
+    # Without globalCallingHandlers (see header), pick warnings up from
+    # last.warning. It lingers across commands, so only report it when it
+    # changed since the previous command.
+    if (!isTRUE(.console_state$gch_installed)) {
+      lw <- tryCatch(get0("last.warning", envir = baseenv(), inherits = FALSE),
+                     error = function(e) NULL)
+      if (!is.null(lw) && !identical(lw, .console_state$last_lw)) {
+        .console_state$last_lw <- lw
+        lines <- c(lines, paste0("#> warning: ", names(lw)))
+      }
+    }
     if (length(.console_state$pending)) {
       lines <- c(.console_state$pending, lines)
       .console_state$pending <- NULL
@@ -153,45 +173,67 @@ console_task_callback <- function(expr, value, ok, visible) {
 #' @return Invisibly TRUE if capture started.
 #' @export
 start_console_logging <- function() {
-  if (isTRUE(.console_state$active)) return(invisible(TRUE))
+  # Called from the console (top level) OR from the addin's Shiny observer.
+  at_top <- sys.nframe() == 1L
+  registered <- "clauder_console_log" %in% getTaskCallbackNames()
+  if (isTRUE(.console_state$active) && registered) return(invisible(TRUE))
   .console_state$pending <- NULL
-  # Order matters. globalCallingHandlers() cannot be wrapped in tryCatch (it
-  # refuses to run with handlers on the stack), so it goes first: if it fails,
-  # it fails before a sink or a callback has been installed, leaving nothing
-  # half-configured behind.
-  if (getRversion() >= "4.0.0") {
+  .console_state$last_lw <- tryCatch(get0("last.warning", envir = baseenv(), inherits = FALSE),
+                                     error = function(e) NULL)
+
+  # 1. The essential half, first and unconditionally: the task callback that
+  #    writes each command. Nothing below may prevent this from being armed.
+  if (!registered) {
+    .console_state$handle <- addTaskCallback(console_task_callback,
+                                             name = "clauder_console_log")
+  }
+
+  # 2. Printed output (optional). If the sink cannot be opened we still log
+  #    commands and their values.
+  ok_sink <- isTRUE(tryCatch({ console_sink_open(); TRUE }, error = function(e) FALSE))
+
+  # 3. Uncaught errors.
+  if (is.null(.console_state$old_error_set)) {
+    .console_state$old_error <- getOption("error")
+    .console_state$old_error_set <- TRUE
+  }
+  options(error = function() {
+    tryCatch({
+      msg <- geterrmessage()
+      console_write(sprintf("#> error: %s", trimws(msg)), tag = "user")
+    }, error = function(e) NULL)
+  })
+
+  .console_state$active <- TRUE
+
+  # 4. Warnings and messages via globalCallingHandlers, LAST, and only from a
+  #    bare top-level call (see header). Not wrapped in tryCatch: that would
+  #    itself put a handler on the stack and guarantee the error.
+  if (!isTRUE(.console_state$gch_installed) && at_top && getRversion() >= "4.0.0") {
     .console_state$old_handlers <- globalCallingHandlers()
     # Observe only. Do NOT invoke the muffle restarts: the user must still see
     # their own warnings and messages in the console.
     globalCallingHandlers(
       warning = function(w) console_note_condition("warning", conditionMessage(w)),
       message = function(m) console_note_condition("message", conditionMessage(m))
     )
+    .console_state$gch_installed <- TRUE
   }
-  # Capturing printed output is the optional half. If the sink cannot be opened
-  # the callback must still be registered, or a failure here would silently
-  # stop commands being logged at all, which is worse than losing the output.
-  ok_sink <- isTRUE(tryCatch({ console_sink_open(); TRUE },
-                             error = function(e) FALSE))
-  .console_state$handle <- addTaskCallback(console_task_callback,
-                                           name = "clauder_console_log")
-  .console_state$old_error <- getOption("error")
-  options(error = function() {
-    tryCatch({
-      msg <- geterrmessage()
-      console_write(sprintf("#> error: %s", trimws(msg)), tag = "user")
-    }, error = function(e) NULL)
-  })
+
   reg.finalizer(.console_state,
                 function(e) tryCatch(console_sink_close(), error = function(x) NULL),
                 onexit = TRUE)
-  .console_state$active <- TRUE
   message("ClaudeR: console logging on. Your console commands now appear in the session log.")
   if (!ok_sink) {
     message("ClaudeR: could not capture printed output here; ",
             "commands and their values will still be logged.")
   }
-  # Our own startup message must not show up as the user's first log entry.
+  if (!isTRUE(.console_state$gch_installed)) {
+    message("ClaudeR: warnings are logged from last.warning; message() output is not ",
+            "captured when logging is started from the addin. Run ",
+            "start_console_logging() in the console for full capture.")
+  }
+  # Our own startup messages must not show up as the user's first log entry.
   .console_state$pending <- NULL
   invisible(TRUE)
 }
@@ -201,17 +243,25 @@ start_console_logging <- function() {
 #' @return Invisibly TRUE.
 #' @export
 stop_console_logging <- function() {
-  if (!isTRUE(.console_state$active)) return(invisible(TRUE))
+  at_top <- sys.nframe() == 1L
+  if (!isTRUE(.console_state$active) &&
+      !("clauder_console_log" %in% getTaskCallbackNames())) return(invisible(TRUE))
   tryCatch(removeTaskCallback("clauder_console_log"), error = function(e) NULL)
   console_sink_close()
-  if (getRversion() >= "4.0.0") {
+  if (isTRUE(.console_state$gch_installed) && at_top) {
     # Drop ours, then put back whatever was registered before, so handlers
-    # belonging to other packages survive.
+    # belonging to other packages survive. Only possible at bare top level;
+    # from the addin the handlers stay installed but become no-ops because
+    # console_note_condition() checks .console_state$active.
     globalCallingHandlers(NULL)
     old <- .console_state$old_handlers
     if (length(old)) do.call(globalCallingHandlers, old)
+    .console_state$gch_installed <- FALSE
+  }
+  if (isTRUE(.console_state$old_error_set)) {
+    options(error = .console_state$old_error)
+    .console_state$old_error_set <- NULL
   }
-  options(error = .console_state$old_error)
   .console_state$active <- FALSE
   .console_state$pending <- NULL
   message("ClaudeR: console logging off.")

README.md

@@ -50,6 +50,8 @@ claudeAddin()
 <details>
 <summary><b>Recent Updates</b> (click to expand)</summary>
 
+- **Console logging from the addin fixed (R 0.14.2).** Ticking "Also log my own console commands" in the addin armed nothing on 0.14.1, while calling `start_console_logging()` in the console worked. Cause: `globalCallingHandlers()` (used to observe warnings and messages) can only be called with an empty handler stack, and inside the Shiny observer that handles the checkbox it errors, which aborted the function before the console callback was registered. The callback is now registered first and unconditionally; the handlers are installed only when logging is started from the console, and otherwise warnings are read from `last.warning` after each command. Started from the addin, `message()` output is the one thing not captured, and the addin says so.
+
 - **Logging fixes (R 0.14.1).** Two problems from a user report. Agent output was never written to the log, only the code, because the entry was written before the code ran; the log now records what each call printed. And the output capture added in 0.14.0 could stop console logging entirely: it opened its own output sink before registering the console callback, so if that sink could not be opened, nothing was logged at all. Opening it is now optional and failing back to logging commands and their values, the sink is restored if another execution unwinds it, and an agent run no longer pops a sink it did not open. Logged output lines are marked so that replay, history and notebook export skip them.
 
 - **Console logging now captures output, not just results (R 0.14.0).** From follow-up on the logging request. The log recorded the value a command returned, so anything printed as a side effect was missing: `cat()`, progress output, and `print()` called inside a function. Running `f()` showed the call but not what `f()` printed, which is exactly the context an agent needs when you hand it an error you hit yourself. Standard output is now teed to the log and grouped under the command that produced it, alongside the warnings, messages, and errors already captured. Your console still shows everything as normal.