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

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

@@ -12,6 +12,7 @@ var path = require("path");
 var child_process_1 = require("child_process");
 var net_1 = require("net");
 var windowsConoutConnection_1 = require("./windowsConoutConnection");
+var eventEmitter2_1 = require("./eventEmitter2");
 var utils_1 = require("./utils");
 var conptyNative;
 /**
@@ -20,16 +21,23 @@ 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;
+        this._onError = new eventEmitter2_1.EventEmitter2();
         if (!conptyNative) {
             conptyNative = (0, utils_1.loadNativeModule)('conpty').module;
         }
@@ -52,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');
         });
@@ -81,6 +91,11 @@ var WindowsPtyAgent = /** @class */ (function () {
         });
         this._inSocket.setEncoding('utf8');
     }
+    Object.defineProperty(WindowsPtyAgent.prototype, "onError", {
+        get: function () { return this._onError.event; },
+        enumerable: false,
+        configurable: true
+    });
     Object.defineProperty(WindowsPtyAgent.prototype, "inSocket", {
         get: function () { return this._inSocket; },
         enumerable: false,
@@ -108,13 +123,54 @@ var WindowsPtyAgent = /** @class */ (function () {
     });
     WindowsPtyAgent.prototype._completePtyConnection = function () {
         var _this = this;
+        var _a;
+        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 {
+            var connect = conptyNative.connect(pty, commandLine, cwd, env, this._useConptyDll, function (c) { return _this._$onProcessExit(c); });
+            this._innerPid = connect.pid;
+        }
+        catch (err) {
+            // 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;
+            try {
+                this._ptyNative.kill(this._pty, this._useConptyDll);
+            }
+            catch ( /* already gone */_c) { /* already gone */ }
+            this._conoutSocketWorker.dispose();
+            this._inSocket.destroy();
+            this._outSocket.destroy();
+            this._onError.fire(err);
+        }
+    };
+    WindowsPtyAgent.prototype._failPtyConnection = function (error) {
         if (!this._pendingPtyInfo) {
             return;
         }
-        var _a = this._pendingPtyInfo, pty = _a.pty, commandLine = _a.commandLine, cwd = _a.cwd, env = _a.env;
+        this._clearConnectionTimeout();
         this._pendingPtyInfo = undefined;
-        var connect = conptyNative.connect(pty, commandLine, cwd, env, this._useConptyDll, function (c) { return _this._$onProcessExit(c); });
-        this._innerPid = connect.pid;
+        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) {
@@ -128,6 +184,7 @@ var WindowsPtyAgent = /** @class */ (function () {
     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

@@ -52,6 +52,12 @@ var WindowsTerminal = /** @class */ (function (_super) {
         // Create new termal.
         _this._agent = new windowsPtyAgent_1.WindowsPtyAgent(file, args, parsedEnv, cwd, _this._cols, _this._rows, false, opt.useConptyDll, opt.conptyInheritCursor);
         _this._socket = _this._agent.outSocket;
+        // The socket 'close' handler that drives 'exit' is only attached after
+        // ready_datapipe, which never fires when connect() fails.
+        _this._agent.onError(function () {
+            _this._close();
+            _this.emit('exit', _this._agent.exitCode);
+        });
         // Not available until `ready` event emitted.
         _this._pid = _this._agent.innerPid;
         _this._fd = _this._agent.fd;

package/package.json

@@ -4,7 +4,7 @@
   "author": {
     "name": "Microsoft Corporation"
   },
-  "version": "1.2.0-beta.13",
+  "version": "1.2.0-beta.15",
   "license": "MIT",
   "main": "./lib/index.js",
   "types": "./typings/node-pty.d.ts",
@@ -56,7 +56,8 @@
     "@typescript-eslint/eslint-plugin": "^8.0.0",
     "@typescript-eslint/parser": "^8.0.0",
     "cross-env": "^5.1.4",
-    "eslint": "^9.0.0",
+    "eslint": "^10.4.0",
+    "globals": "^14.0.0",
     "mocha": "10",
     "node-gyp": "^11.4.2",
     "ps-list": "^6.0.0",

package/src/unix/pty.cc

@@ -203,6 +203,7 @@ void SetupExitCallback(Napi::Env env, Napi::Function cb, pid_t pid) {
         }
       }
     }
+    close(kq);
 #else
     while (true) {
       errno = 0;

package/src/win/conpty.cc

@@ -46,7 +46,7 @@ struct pty_baton {
   HANDLE hOut;
   HPCON hpc;
 
-  HANDLE hShell;
+  HANDLE hShell = nullptr;
 
   pty_baton(int _id, HANDLE _hIn, HANDLE _hOut, HPCON _hpc) : id(_id), hIn(_hIn), hOut(_hOut), hpc(_hpc) {};
 };
@@ -384,6 +384,14 @@ static Napi::Value PtyConnect(const Napi::CallbackInfo& info) {
   ConnectNamedPipe(handle->hIn, nullptr);
   ConnectNamedPipe(handle->hOut, nullptr);
 
+  // Close hIn/hOut on every exit so a throw doesn't leak the named-pipe server handles.
+  auto closePipeHandles = [handle]() {
+    CloseHandle(handle->hIn);
+    CloseHandle(handle->hOut);
+    handle->hIn = nullptr;
+    handle->hOut = nullptr;
+  };
+
   // Attach the pseudoconsole to the client application we're creating
   STARTUPINFOEXW siEx{0};
   siEx.StartupInfo.cb = sizeof(STARTUPINFOEXW);
@@ -394,12 +402,14 @@ static Napi::Value PtyConnect(const Napi::CallbackInfo& info) {
 
   SIZE_T size = 0;
   InitializeProcThreadAttributeList(NULL, 1, 0, &size);
-  BYTE *attrList = new BYTE[size];
-  siEx.lpAttributeList = reinterpret_cast<PPROC_THREAD_ATTRIBUTE_LIST>(attrList);
+  std::unique_ptr<BYTE[]> attrList = std::make_unique<BYTE[]>(size);
+  siEx.lpAttributeList = reinterpret_cast<PPROC_THREAD_ATTRIBUTE_LIST>(attrList.get());
 
   fSuccess = InitializeProcThreadAttributeList(siEx.lpAttributeList, 1, 0, &size);
   if (!fSuccess) {
-    throw errorWithCode(info, "InitializeProcThreadAttributeList failed");
+    Napi::Error error = errorWithCode(info, "InitializeProcThreadAttributeList failed");
+    closePipeHandles();
+    throw error;
   }
   fSuccess = UpdateProcThreadAttribute(siEx.lpAttributeList,
                                        0,
@@ -409,7 +419,10 @@ static Napi::Value PtyConnect(const Napi::CallbackInfo& info) {
                                        NULL,
                                        NULL);
   if (!fSuccess) {
-    throw errorWithCode(info, "UpdateProcThreadAttribute failed");
+    Napi::Error error = errorWithCode(info, "UpdateProcThreadAttribute failed");
+    DeleteProcThreadAttributeList(siEx.lpAttributeList);
+    closePipeHandles();
+    throw error;
   }
 
   PROCESS_INFORMATION piClient{};
@@ -426,9 +439,14 @@ static Napi::Value PtyConnect(const Napi::CallbackInfo& info) {
       &piClient                     // lpProcessInformation
   );
   if (!fSuccess) {
-    throw errorWithCode(info, "Cannot create process");
+    Napi::Error error = errorWithCode(info, "Cannot create process");
+    DeleteProcThreadAttributeList(siEx.lpAttributeList);
+    closePipeHandles();
+    throw error;
   }
 
+  DeleteProcThreadAttributeList(siEx.lpAttributeList);
+
   HANDLE hLibrary = LoadConptyDll(info, useConptyDll);
   bool fLoadedDll = hLibrary != nullptr;
   if (useConptyDll && fLoadedDll)
@@ -447,8 +465,7 @@ static Napi::Value PtyConnect(const Napi::CallbackInfo& info) {
   // Close the thread handle to avoid resource leak
   CloseHandle(piClient.hThread);
   // Close the input read and output write handle of the pseudoconsole
-  CloseHandle(handle->hIn);
-  CloseHandle(handle->hOut);
+  closePipeHandles();
 
   SetupExitCallback(env, exitCallback, handle);
 
@@ -550,7 +567,7 @@ static Napi::Value PtyKill(const Napi::CallbackInfo& info) {
   const bool useConptyDll = info[1].As<Napi::Boolean>().Value();
 
   std::lock_guard<std::mutex> lock(g_ptyHandlesMutex);
-  const pty_baton* handle = get_pty_baton(lock, id);
+  pty_baton* handle = get_pty_baton(lock, id);
 
   if (handle != nullptr) {
     HANDLE hLibrary = LoadConptyDll(info, useConptyDll);
@@ -565,7 +582,17 @@ static Napi::Value PtyKill(const Napi::CallbackInfo& info) {
         pfnClosePseudoConsole(handle->hpc);
       }
     }
-    if (useConptyDll) {
+    // Defensive: if PtyConnect was never called (or failed before closing the
+    // pipe handles), release the named pipe server handles here.
+    if (handle->hIn != nullptr) {
+      CloseHandle(handle->hIn);
+      handle->hIn = nullptr;
+    }
+    if (handle->hOut != nullptr) {
+      CloseHandle(handle->hOut);
+      handle->hOut = nullptr;
+    }
+    if (useConptyDll && handle->hShell != nullptr) {
       TerminateProcess(handle->hShell, 1);
     }
   }