feat: add session attachment preparation API (#1868)

External R frontends cannot discover vscode-R's managed sess package through ordinary package lookup.
Exposing installation paths would also require consumers to duplicate revision checks, installation consent, and setup locking.
This adds `session.prepareAttachment()` so a consumer can execute opaque R code prepared by vscode-R, including through its own local sess proxy endpoint.

This provides the higher-level preparation API discussed in #1865, while keeping `getConnectionInfo()` independent of package preparation.

- Return a per-call, disposable `scriptPath` and R `command`; keep the shared consent service and managed library details internal. Guard script, consent, and IPC initialization against shutdown/redeploy races.
- Reuse the existing managed sess setup for external and manual attachment. Generated scripts handle errors and interrupts without preventing the next R prompt, and manual attachment passes the configured RStudio API emulation setting.
- Document resource lifetime, local endpoint requirements, existing automatic selection behavior, terminal registration after connection, and the R-side consent/setup waits. Add regression coverage for endpoint rejection, independent disposal, concurrent preparation, teardown races, and generated R script execution.

This PR covers preparation only.
Connection lifecycle notifications, terminal rebinding, and external terminal attach hooks remain follow-up work.

Author: eitsupi

CHANGELOG.md

@@ -2,6 +2,7 @@
 
 ## Unreleased
 
+- Added the extension API's `session.prepareAttachment()` for extensions that own an R process and need vscode-R's managed `sess` setup. R errors and interrupts during manual attachment are now reported as messages while leaving the R prompt usable.
 - The httpgd plot backend now requires the `httpgd` R package version 2.0.1 or later. Older versions are treated as unavailable when choosing the plot backend. (#1855)
 
 ## 3.0.1 - 2026-09-28

R/attach_sess.R

@@ -16,7 +16,11 @@ vscode_r_prepare_sess <- function(pkg_path, managed_root, consent_dir,
     if (loaded) {
         loaded_revision <- sess_loaded_source_revision()
         if (!identical(loaded_revision, expected)) {
-            stop("A different sess namespace is already loaded. Restart R before attaching the session watcher.")
+            stop(paste(
+                "A different sess namespace is already loaded.",
+                "Close this R session and start a new one before attaching the session watcher.",
+                "Reloading VS Code does not restart a persistent R session."
+            ))
         }
         ns <- asNamespace("sess")
     } else {
@@ -178,7 +182,8 @@ vscode_r_prepare_sess <- function(pkg_path, managed_root, consent_dir,
 vscode_r_attach_sess <- function(endpoint, pkg_path, managed_root, consent_dir,
                                  source_helper, installer_helper, plot_backend,
                                  timeout_seconds = 180,
-                                 setup_timeout_seconds = 300) {
+                                 setup_timeout_seconds = 300,
+                                 use_rstudioapi = TRUE) {
     registered <- getOption("vscodeR.terminalStartup")
     profile_process <- is.list(registered) && identical(registered$pid, Sys.getpid())
     startup_context <- NULL
@@ -213,7 +218,8 @@ vscode_r_attach_sess <- function(endpoint, pkg_path, managed_root, consent_dir,
             return(invisible(FALSE))
         }
         connect <- get("connect", envir = ns, inherits = FALSE)
-        connect(endpoint = endpoint, plot_backend = plot_backend)
+        connect(endpoint = endpoint, plot_backend = plot_backend,
+                use_rstudioapi = use_rstudioapi)
     }
 
     if (profile_process) {

R/tests/attach_sess.R

@@ -16,7 +16,9 @@ writeLines(c(
     paste0("Config/vscode-R/source-revision: ", revision)
 ), file.path(pkg, "DESCRIPTION"))
 writeLines(c(
-    "connect <- function(endpoint=NULL, plot_backend=NULL, ...) TRUE",
+    "connect <- function(endpoint=NULL, plot_backend=NULL, use_rstudioapi=TRUE, ...) {",
+    "  options(vscodeR.test.use_rstudioapi=use_rstudioapi); TRUE",
+    "}",
     "notify_client <- function(...) NULL", "request_client <- function(...) NULL",
     ".onLoad <- function(libname, pkgname) {",
     "  complete <- Sys.getenv('VSCODE_R_TEST_INSTALL_COMPLETE', '')",
@@ -113,12 +115,13 @@ writeLines(c(
     "  stopifnot(file.exists(file.path(root, 'user-profile-ran'))) ",
     "  stopifnot(any(normalizePath(.libPaths()) == normalizePath(project_library)))",
     "}",
-    "attach_sess <- function(endpoint='endpoint', timeout=180, setup_timeout=8) {",
+    "attach_sess <- function(endpoint='endpoint', timeout=180, setup_timeout=8, use_rstudioapi=TRUE) {",
     "  vscode_r_attach_sess(endpoint, pkg, managed_root, consent,",
     "    file.path(getwd(), 'R', 'sess_source.R'),",
     "    if (nzchar(install_helper)) install_helper else",
     "      file.path(getwd(), 'R', 'sess-package-install.R'),",
-    "    'standard', timeout_seconds=timeout, setup_timeout_seconds=setup_timeout)",
+    "    'standard', timeout_seconds=timeout, setup_timeout_seconds=setup_timeout,",
+    "    use_rstudioapi=use_rstudioapi)",
     "}",
     "publish_result <- function(value) {",
     "  temporary <- tempfile(tmpdir=dirname(result_file))",
@@ -134,14 +137,20 @@ writeLines(c(
     "  utils::install.packages(pkg, repos=NULL, type='source', lib=expected, quiet=TRUE)",
     "  if (mode == 'prepared') writeLines(revision, ready_path)",
     "  if (mode %in% c('exact', 'prepared')) {",
-    "    result <- attach_sess(timeout=0)",
+    "    result <- attach_sess(timeout=0, use_rstudioapi=FALSE)",
     "    stopifnot(identical(result, TRUE), same_paths(.libPaths(), ordinary))",
+    "    stopifnot(identical(getOption('vscodeR.test.use_rstudioapi'), FALSE))",
     "    stopifnot(identical(sess_loaded_source_revision(), revision))",
     "    actual <- getNamespaceInfo(asNamespace('sess'), 'path')",
     "    stopifnot(same_paths(actual, file.path(expected, 'sess')))",
     "    if (mode == 'prepared') stopifnot(identical(readLines(ready_path), revision))",
     "    stopifnot(length(list.files(consent, pattern='\\\\.request$')) == 0L)",
     "    if (mode == 'exact') {",
+    "      legacy_result <- vscode_r_attach_sess('endpoint', pkg, managed_root, consent,",
+    "        file.path(getwd(), 'R', 'sess_source.R'),",
+    "        file.path(getwd(), 'R', 'sess-package-install.R'), 'standard', 0)",
+    "      stopifnot(identical(legacy_result, TRUE),",
+    "                identical(getOption('vscodeR.test.use_rstudioapi'), TRUE))",
     "      blocked_file <- file.path(root, 'missing-directory', 'startup')",
     "      context <- vscode_r_startup_register(blocked_file, strrep('c', 32), 'endpoint')",
     "      called <- FALSE",

src/api.d.ts

@@ -33,9 +33,48 @@ export interface RSessionActivationOptions {
     terminal?: vscode.Terminal;
 }
 
+export interface RSessionPreparationOptions {
+    /**
+     * A local sess IPC endpoint on the current R host, such as a proxy socket.
+     * When omitted, vscode-R's endpoint is used. Only sess IPC is supported.
+     * On Windows, only a local `\\.\pipe\...` named pipe with a non-empty
+     * name containing ASCII letters, digits, underscore, period, or hyphen is
+     * accepted. On other platforms, an absolute local socket path is required.
+     */
+    connection?: {
+        transport: 'sess';
+        endpoint: string;
+    };
+}
+
+/** Opaque R code and script resource for preparing sess in a consumer-owned R process. */
+export interface RSessionPreparation extends vscode.Disposable {
+    /** Source this file in the target R process; its contents are private to vscode-R. */
+    readonly scriptPath: string;
+    /** R source(...) expression for scriptPath. This is R code, not a shell command. */
+    readonly command: string;
+}
+
 export interface RSessionApi {
     /** Returns connection details, or undefined when the session watcher is disabled. */
     getConnectionInfo(): Promise<RSessionConnectionInfo | undefined>;
+    /**
+     * Prepare managed sess integration for a consumer-owned R process on the current host.
+     * Source `command` in that process after its user profile. The command handles R errors
+     * and interrupts itself, reports a diagnostic and returns `invisible(FALSE)`; preparation
+     * failures reject this promise. Returns undefined, without starting resources, when the
+     * session watcher is disabled. The returned script is valid only for this extension-host
+     * lifetime. Keep the resource until source execution finishes, then dispose it. If the
+     * consumer cannot observe completion, retain it for the R process lifetime. Disposing
+     * removes only this script; it does not stop the R process or disconnect sess.
+     *
+     * Attaching follows vscode-R's current automatic-selection rules and may change the UI's
+     * selected session. After connection, call `activate(sessionId, { terminal })` to register
+     * the consumer's execution terminal; connection replacement clears that registration.
+     * During script execution, R may wait up to 180 seconds for install consent or 300 seconds
+     * for another setup's lock. These are R-side waits, not a total startup timeout.
+     */
+    prepareAttachment(options?: RSessionPreparationOptions): Promise<RSessionPreparation | undefined>;
     /**
      * Activates a connected session, optionally binding its execution terminal.
      * Omitting terminal preserves any existing binding. Returns false for unknown

src/extension.ts

@@ -62,6 +62,7 @@ export async function activate(context: vscode.ExtensionContext): Promise<apiImp
     const rExtension = new apiImplementation.RExtensionImplementation();
     rExtension.session = {
         getConnectionInfo: session.getConnectionInfo,
+        prepareAttachment: session.prepareAttachment,
         activate: session.activateSessionById,
     };