node-pty 1.2.0-beta.14 → 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/windowsConoutConnection.js

@@ -50,25 +50,15 @@ var eventEmitter2_1 = require("./eventEmitter2");
  * the timer has started.
  */
 var FLUSH_DATA_INTERVAL = 1000;
-/**
- * Connects to and manages the lifecycle of the conout socket. This socket must be drained on
- * another thread in order to avoid deadlocks where Conpty waits for the out socket to drain
- * when `ClosePseudoConsole` is called. This happens when data is being written to the terminal when
- * the pty is closed.
- *
- * See also:
- * - https://github.com/microsoft/node-pty/issues/375
- * - https://github.com/microsoft/vscode/issues/76548
- * - https://github.com/microsoft/terminal/issues/1810
- * - https://docs.microsoft.com/en-us/windows/console/closepseudoconsole
- */
 var ConoutConnection = /** @class */ (function () {
     function ConoutConnection(_conoutPipeName, _useConptyDll) {
         var _this = this;
         this._conoutPipeName = _conoutPipeName;
         this._useConptyDll = _useConptyDll;
         this._isDisposed = false;
+        this._isReady = false;
         this._onReady = new eventEmitter2_1.EventEmitter2();
+        this._onError = new eventEmitter2_1.EventEmitter2();
         var workerData = {
             conoutPipeName: _conoutPipeName
         };
@@ -77,18 +67,34 @@ var ConoutConnection = /** @class */ (function () {
         this._worker.on('message', function (message) {
             switch (message) {
                 case 1 /* ConoutWorkerMessage.READY */:
+                    _this._isReady = true;
                     _this._onReady.fire();
                     return;
                 default:
                     console.warn('Unexpected ConoutWorkerMessage', message);
             }
         });
+        this._worker.on('error', function (error) {
+            if (!_this._isDisposed && !_this._isReady) {
+                _this._onError.fire(error);
+            }
+        });
+        this._worker.on('exit', function (code) {
+            if (!_this._isDisposed && !_this._isReady) {
+                _this._onError.fire(new Error("Conout worker exited before connecting (code ".concat(code, ")")));
+            }
+        });
     }
     Object.defineProperty(ConoutConnection.prototype, "onReady", {
         get: function () { return this._onReady.event; },
         enumerable: false,
         configurable: true
     });
+    Object.defineProperty(ConoutConnection.prototype, "onError", {
+        get: function () { return this._onError.event; },
+        enumerable: false,
+        configurable: true
+    });
     ConoutConnection.prototype.dispose = function () {
         if (!this._useConptyDll && this._isDisposed) {
             return;

package/lib/windowsPtyAgent.js

@@ -21,13 +21,19 @@ var conptyNative;
  * has started.
  */
 var FLUSH_DATA_INTERVAL = 1000;
+var CONNECTION_TIMEOUT = 5000;
+var defaultWindowsPtyAgentOptions = {
+    connectionTimeout: CONNECTION_TIMEOUT,
+    conoutConnectionFactory: function (conoutPipeName, useConptyDll) { return new windowsConoutConnection_1.ConoutConnection(conoutPipeName, useConptyDll); }
+};
 /**
  * This agent sits between the WindowsTerminal class and provides an interface for conpty.
  */
 var WindowsPtyAgent = /** @class */ (function () {
-    function WindowsPtyAgent(file, args, env, cwd, cols, rows, debug, _useConptyDll, conptyInheritCursor) {
+    function WindowsPtyAgent(file, args, env, cwd, cols, rows, debug, _useConptyDll, conptyInheritCursor, options) {
         if (_useConptyDll === void 0) { _useConptyDll = false; }
         if (conptyInheritCursor === void 0) { conptyInheritCursor = false; }
+        if (options === void 0) { options = defaultWindowsPtyAgentOptions; }
         var _this = this;
         this._useConptyDll = _useConptyDll;
         this._innerPid = 0;
@@ -54,24 +60,26 @@ var WindowsPtyAgent = /** @class */ (function () {
         // We must wait for the worker to connect before calling conptyNative.connect()
         // to avoid blocking the Node.js event loop in ConnectNamedPipe.
         // See https://github.com/microsoft/node-pty/issues/763
-        this._conoutSocketWorker = new windowsConoutConnection_1.ConoutConnection(term.conout, this._useConptyDll);
+        this._conoutSocketWorker = options.conoutConnectionFactory(term.conout, this._useConptyDll);
         // Store pending connection info - we'll complete the connection when worker is ready
         this._pendingPtyInfo = { pty: this._pty, commandLine: commandLine, cwd: cwd, env: env };
-        // Timeout to ensure connection completes even if worker fails to signal ready
-        var connectionTimeout = setTimeout(function () {
-            if (_this._pendingPtyInfo) {
-                // Worker never signaled ready - complete connection anyway to avoid zombie state
-                _this._completePtyConnection();
-            }
-        }, 5000);
+        // Never call connect() before the worker is ready, as ConnectNamedPipe
+        // would block the Node.js event loop while waiting for the output client.
+        this._connectionTimeout = setTimeout(function () {
+            _this._failPtyConnection(new Error('Timed out waiting for ConPTY output worker'));
+        }, options.connectionTimeout);
         this._conoutSocketWorker.onReady(function () {
-            clearTimeout(connectionTimeout);
+            if (!_this._pendingPtyInfo) {
+                return;
+            }
+            _this._clearConnectionTimeout();
             _this._conoutSocketWorker.connectSocket(_this._outSocket);
             // Now that the worker has connected to the output pipe, we can safely call
             // conptyNative.connect() which calls ConnectNamedPipe - it won't block because
             // the client (worker) is already connected
             _this._completePtyConnection();
         });
+        this._conoutSocketWorker.onError(function (error) { return _this._failPtyConnection(error); });
         this._outSocket.on('connect', function () {
             _this._outSocket.emit('ready_datapipe');
         });
@@ -119,6 +127,7 @@ var WindowsPtyAgent = /** @class */ (function () {
         if (!this._pendingPtyInfo) {
             return;
         }
+        this._clearConnectionTimeout();
         var _b = this._pendingPtyInfo, pty = _b.pty, commandLine = _b.commandLine, cwd = _b.cwd, env = _b.env;
         this._pendingPtyInfo = undefined;
         try {
@@ -126,8 +135,8 @@ var WindowsPtyAgent = /** @class */ (function () {
             this._innerPid = connect.pid;
         }
         catch (err) {
-            // connect() runs from the conout worker's onReady callback (or its
-            // timeout fallback), so a throw here would otherwise surface as an
+            // connect() runs from the conout worker's onReady callback, so a throw
+            // here would otherwise surface as an
             // uncaughtException with no way for the consumer to observe it.
             var code = (_a = /error code: (\d+)/.exec(err.message)) === null || _a === void 0 ? void 0 : _a[1];
             this._exitCode = code ? parseInt(code, 10) : -1;
@@ -141,6 +150,28 @@ var WindowsPtyAgent = /** @class */ (function () {
             this._onError.fire(err);
         }
     };
+    WindowsPtyAgent.prototype._failPtyConnection = function (error) {
+        if (!this._pendingPtyInfo) {
+            return;
+        }
+        this._clearConnectionTimeout();
+        this._pendingPtyInfo = undefined;
+        this._exitCode = -1;
+        try {
+            this._ptyNative.kill(this._pty, this._useConptyDll);
+        }
+        catch ( /* already gone */_a) { /* already gone */ }
+        this._conoutSocketWorker.dispose();
+        this._inSocket.destroy();
+        this._outSocket.destroy();
+        this._onError.fire(error);
+    };
+    WindowsPtyAgent.prototype._clearConnectionTimeout = function () {
+        if (this._connectionTimeout) {
+            clearTimeout(this._connectionTimeout);
+            this._connectionTimeout = undefined;
+        }
+    };
     WindowsPtyAgent.prototype.resize = function (cols, rows) {
         if (this._exitCode !== undefined) {
             throw new Error('Cannot resize a pty that has already exited');
@@ -150,9 +181,19 @@ 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
+        this._clearConnectionTimeout();
         this._pendingPtyInfo = undefined;
         // Tell the agent to kill the pty, this releases handles to the process
         if (!this._useConptyDll) {

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.14",
+  "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.