node-pty 1.2.0-beta.15 → 1.2.0-beta.16

package/lib/unixTerminal.js

@@ -261,6 +261,10 @@ var UnixTerminal = /** @class */ (function (_super) {
     };
     UnixTerminal.prototype.clear = function () {
     };
+    UnixTerminal.prototype.setParentWindow = function (handle) {
+        // Windows only
+        return false;
+    };
     UnixTerminal.prototype._sanitizeEnv = function (env) {
         // Make sure we didn't start our server from inside tmux.
         delete env['TMUX'];

package/lib/windowsPtyAgent.js

@@ -181,6 +181,15 @@ var WindowsPtyAgent = /** @class */ (function () {
     WindowsPtyAgent.prototype.clear = function () {
         this._ptyNative.clear(this._pty, this._useConptyDll);
     };
+    /**
+     * Tells ConPTY which top-level window hosts the terminal (ConptyReparentPseudoConsole). The
+     * window becomes the owner of the console window returned by GetConsoleWindow(), so dialogs
+     * that console apps parent to it (e.g. WAM sign-in) stack above the host window. Returns
+     * whether the request was sent to ConPTY, which applies it asynchronously.
+     */
+    WindowsPtyAgent.prototype.setParentWindow = function (handle) {
+        return this._ptyNative.reparent(this._pty, handle, this._useConptyDll);
+    };
     WindowsPtyAgent.prototype.kill = function () {
         var _this = this;
         // Prevent deferred connection from completing after kill

package/lib/windowsTerminal.js

@@ -148,6 +148,11 @@ var WindowsTerminal = /** @class */ (function (_super) {
             _this._agent.clear();
         });
     };
+    WindowsTerminal.prototype.setParentWindow = function (handle) {
+        // Not deferred: the pseudoconsole exists as soon as the agent is created, and the owner
+        // should be requested before the shell starts asking for it.
+        return this._agent.setParentWindow(handle);
+    };
     WindowsTerminal.prototype.destroy = function () {
         var _this = this;
         this._deferNoArgs(function () {

package/package.json

@@ -4,7 +4,7 @@
   "author": {
     "name": "Microsoft Corporation"
   },
-  "version": "1.2.0-beta.15",
+  "version": "1.2.0-beta.16",
   "license": "MIT",
   "main": "./lib/index.js",
   "types": "./typings/node-pty.d.ts",
@@ -27,6 +27,18 @@
   "bugs": {
     "url": "https://github.com/microsoft/node-pty/issues"
   },
+  "devEngines": {
+    "runtime": {
+      "name": "node",
+      "version": ">=24",
+      "onFail": "error"
+    },
+    "packageManager": {
+      "name": "npm",
+      "version": ">=11.6.3",
+      "onFail": "error"
+    }
+  },
   "keywords": [
     "pty",
     "tty",
@@ -51,15 +63,14 @@
     "node-addon-api": "^7.1.0"
   },
   "devDependencies": {
-    "@types/mocha": "^7.0.2",
+    "@types/mocha": "^10.0.10",
     "@types/node": "12",
     "@typescript-eslint/eslint-plugin": "^8.0.0",
     "@typescript-eslint/parser": "^8.0.0",
     "cross-env": "^5.1.4",
     "eslint": "^10.4.0",
     "globals": "^14.0.0",
-    "mocha": "10",
-    "node-gyp": "^11.4.2",
+    "mocha": "12.0.2",
     "ps-list": "^6.0.0",
     "typescript": "^5.0.0"
   }

package/src/win/conpty.cc

@@ -15,6 +15,7 @@
 #include <assert.h>
 #include <Shlwapi.h> // PathCombine, PathIsRelative
 #include <atomic>
+#include <cstring>
 #include <mutex>
 #include <sstream>
 #include <iostream>
@@ -40,6 +41,9 @@ typedef void (__stdcall *PFNRELEASEPSEUDOCONSOLE)(HPCON hpc);
 
 #endif
 
+// Only exported by the bundled conpty.dll; kernel32 has no equivalent.
+typedef HRESULT (__stdcall *PFNREPARENTPSEUDOCONSOLE)(HPCON hpc, HWND newParent);
+
 struct pty_baton {
   int id;
   HANDLE hIn;
@@ -495,7 +499,7 @@ static Napi::Value PtyResize(const Napi::CallbackInfo& info) {
   std::lock_guard<std::mutex> lock(g_ptyHandlesMutex);
   const pty_baton* handle = get_pty_baton(lock, id);
 
-  if (handle != nullptr) {
+  if (handle != nullptr && handle->hpc != nullptr) {
     HANDLE hLibrary = LoadConptyDll(info, useConptyDll);
     bool fLoadedDll = hLibrary != nullptr;
     if (fLoadedDll)
@@ -537,7 +541,7 @@ static Napi::Value PtyClear(const Napi::CallbackInfo& info) {
   std::lock_guard<std::mutex> lock(g_ptyHandlesMutex);
   const pty_baton* handle = get_pty_baton(lock, id);
 
-  if (handle != nullptr) {
+  if (handle != nullptr && handle->hpc != nullptr) {
     HANDLE hLibrary = LoadConptyDll(info, useConptyDll);
     bool fLoadedDll = hLibrary != nullptr;
     if (fLoadedDll)
@@ -553,6 +557,65 @@ static Napi::Value PtyClear(const Napi::CallbackInfo& info) {
   return env.Undefined();
 }
 
+// The handle is the bytes of an HWND in native byte order, which is how Electron's
+// BrowserWindow.getNativeWindowHandle() returns it.
+static bool TryGetWindowHandle(const Napi::Value& value, HWND* hwnd) {
+  if (!value.IsBuffer()) {
+    return false;
+  }
+  const auto buffer = value.As<Napi::Buffer<uint8_t>>();
+  if (buffer.Length() != sizeof(HWND)) {
+    return false;
+  }
+  std::memcpy(hwnd, buffer.Data(), sizeof(*hwnd));
+  return true;
+}
+
+static Napi::Value PtyReparent(const Napi::CallbackInfo& info) {
+  Napi::Env env(info.Env());
+  Napi::HandleScope scope(env);
+
+  if (info.Length() != 3 ||
+      !info[0].IsNumber() ||
+      !info[2].IsBoolean()) {
+    throw Napi::Error::New(env, "Usage: pty.reparent(id, hwnd, useConptyDll)");
+  }
+
+  int id = info[0].As<Napi::Number>().Int32Value();
+  HWND newParent;
+  if (!TryGetWindowHandle(info[1], &newParent)) {
+    throw Napi::Error::New(env, "pty.reparent: hwnd must be a Buffer the size of an HWND");
+  }
+  const bool useConptyDll = info[2].As<Napi::Boolean>().Value();
+
+  // ConptyReparentPseudoConsole only exists in the bundled conpty.dll.
+  if (!useConptyDll) {
+    return Napi::Boolean::New(env, false);
+  }
+
+  std::lock_guard<std::mutex> lock(g_ptyHandlesMutex);
+  const pty_baton* handle = get_pty_baton(lock, id);
+
+  bool sent = false;
+  if (handle != nullptr && handle->hpc != nullptr) {
+    HANDLE hLibrary = LoadConptyDll(info, useConptyDll);
+    bool fLoadedDll = hLibrary != nullptr;
+    if (fLoadedDll)
+    {
+      PFNREPARENTPSEUDOCONSOLE const pfnReparentPseudoConsole = (PFNREPARENTPSEUDOCONSOLE)GetProcAddress(
+        (HMODULE)hLibrary, "ConptyReparentPseudoConsole");
+      if (pfnReparentPseudoConsole)
+      {
+        // Asks ConPTY to make newParent the owner of the console window returned by
+        // GetConsoleWindow(); ConPTY applies it asynchronously.
+        sent = SUCCEEDED(pfnReparentPseudoConsole(handle->hpc, newParent));
+      }
+    }
+  }
+
+  return Napi::Boolean::New(env, sent);
+}
+
 static Napi::Value PtyKill(const Napi::CallbackInfo& info) {
   Napi::Env env(info.Env());
   Napi::HandleScope scope(env);
@@ -577,9 +640,11 @@ static Napi::Value PtyKill(const Napi::CallbackInfo& info) {
       PFNCLOSEPSEUDOCONSOLE const pfnClosePseudoConsole = (PFNCLOSEPSEUDOCONSOLE)GetProcAddress(
         (HMODULE)hLibrary,
         useConptyDll ? "ConptyClosePseudoConsole" : "ClosePseudoConsole");
-      if (pfnClosePseudoConsole)
+      if (pfnClosePseudoConsole && handle->hpc != nullptr)
       {
         pfnClosePseudoConsole(handle->hpc);
+        // Closing frees the pseudoconsole, but the baton lives until the exit thread erases it.
+        handle->hpc = nullptr;
       }
     }
     // Defensive: if PtyConnect was never called (or failed before closing the
@@ -609,6 +674,7 @@ Napi::Object init(Napi::Env env, Napi::Object exports) {
   exports.Set("connect", Napi::Function::New(env, PtyConnect));
   exports.Set("resize", Napi::Function::New(env, PtyResize));
   exports.Set("clear", Napi::Function::New(env, PtyClear));
+  exports.Set("reparent", Napi::Function::New(env, PtyReparent));
   exports.Set("kill", Napi::Function::New(env, PtyKill));
   return exports;
 };

package/typings/node-pty.d.ts

@@ -173,6 +173,23 @@ declare module 'node-pty' {
      */
     clear(): void;
 
+    /**
+     * Sets the handle (HWND) of the top-level window that hosts this terminal. ConPTY makes it the
+     * owner of the console window returned by `GetConsoleWindow()`, so windows that console
+     * applications parent to it (for example `GetAncestor(GetConsoleWindow(), GA_ROOTOWNER)`, which
+     * MSAL/WAM sign-in uses) open on top of the host window instead of behind it. Calling it right
+     * after spawning sends the request before the process is launched. Call it again whenever the
+     * terminal moves to a different window. Optional so existing implementations of `IPty` keep
+     * compiling.
+     * @param handle The window handle (HWND) as its bytes in native byte order, the way Electron's
+     * `BrowserWindow.getNativeWindowHandle()` returns it. Throws unless it's a Buffer the size of
+     * an HWND (8 bytes in a 64-bit process).
+     * @returns Whether the request was sent to ConPTY, which applies it asynchronously. This is
+     * always false unless on Windows with `useConptyDll`, and false once the pseudoconsole is
+     * closed.
+     */
+    setParentWindow?(handle: Buffer): boolean;
+
     /**
      * Writes data to the pty.
      * @param data The data to write.