node-pty 1.1.0-beta9 → 1.2.0-beta.1

package/src/win/conpty.cc

@@ -11,16 +11,18 @@
 #define _WIN32_WINNT 0x600
 
 #define NODE_ADDON_API_DISABLE_DEPRECATED
-#include <napi.h>
+#include <node_api.h>
 #include <assert.h>
 #include <Shlwapi.h> // PathCombine, PathIsRelative
 #include <sstream>
+#include <iostream>
 #include <string>
 #include <thread>
 #include <vector>
 #include <Windows.h>
 #include <strsafe.h>
 #include "path_util.h"
+#include "conpty.h"
 
 // Taken from the RS5 Windows SDK, but redefined here in case we're targeting <= 17134
 #ifndef PROC_THREAD_ATTRIBUTE_PSEUDOCONSOLE
@@ -32,6 +34,7 @@ typedef HRESULT (__stdcall *PFNCREATEPSEUDOCONSOLE)(COORD c, HANDLE hIn, HANDLE
 typedef HRESULT (__stdcall *PFNRESIZEPSEUDOCONSOLE)(HPCON hpc, COORD newSize);
 typedef HRESULT (__stdcall *PFNCLEARPSEUDOCONSOLE)(HPCON hpc);
 typedef void (__stdcall *PFNCLOSEPSEUDOCONSOLE)(HPCON hpc);
+typedef void (__stdcall *PFNRELEASEPSEUDOCONSOLE)(HPCON hpc);
 
 #endif
 
@@ -46,27 +49,26 @@ struct pty_baton {
   pty_baton(int _id, HANDLE _hIn, HANDLE _hOut, HPCON _hpc) : id(_id), hIn(_hIn), hOut(_hOut), hpc(_hpc) {};
 };
 
-static std::vector<pty_baton*> ptyHandles;
+static std::vector<std::unique_ptr<pty_baton>> ptyHandles;
 static volatile LONG ptyCounter;
 
 static pty_baton* get_pty_baton(int id) {
-  for (size_t i = 0; i < ptyHandles.size(); ++i) {
-    pty_baton* ptyHandle = ptyHandles[i];
-    if (ptyHandle->id == id) {
-      return ptyHandle;
-    }
+  auto it = std::find_if(ptyHandles.begin(), ptyHandles.end(), [id](const auto& ptyHandle) {
+    return ptyHandle->id == id;
+  });
+  if (it != ptyHandles.end()) {
+    return it->get();
   }
   return nullptr;
 }
 
 static bool remove_pty_baton(int id) {
-  for (size_t i = 0; i < ptyHandles.size(); ++i) {
-    pty_baton* ptyHandle = ptyHandles[i];
-    if (ptyHandle->id == id) {
-      ptyHandles.erase(ptyHandles.begin() + i);
-      ptyHandle = nullptr;
-      return true;
-    }
+  auto it = std::remove_if(ptyHandles.begin(), ptyHandles.end(), [id](const auto& ptyHandle) {
+    return ptyHandle->id == id;
+  });
+  if (it != ptyHandles.end()) {
+    ptyHandles.erase(it);
+    return true;
   }
   return false;
 }
@@ -100,16 +102,26 @@ void SetupExitCallback(Napi::Env env, Napi::Function cb, pty_baton* baton) {
     // Get process exit code.
     GetExitCodeProcess(baton->hShell, (LPDWORD)(&exit_event->exit_code));
     // Clean up handles
-    // Calling DisconnectNamedPipes here or in PtyKill results in a crash,
-    // ref https://github.com/microsoft/node-pty/issues/512,
-    // so we only call CloseHandle for now.
-    CloseHandle(baton->hIn);
-    CloseHandle(baton->hOut);
+    CloseHandle(baton->hShell);
+    assert(remove_pty_baton(baton->id));
 
     auto status = tsfn.BlockingCall(exit_event, callback); // In main thread
-    assert(status == napi_ok);
+    switch (status) {
+      case napi_closing:
+        break;
 
-    tsfn.Release();
+      case napi_queue_full:
+        Napi::Error::Fatal("SetupExitCallback", "Queue was full");
+
+      case napi_ok:
+        if (tsfn.Release() != napi_ok) {
+          Napi::Error::Fatal("SetupExitCallback", "ThreadSafeFunction.Release() failed");
+        }
+        break;
+
+      default:
+        Napi::Error::Fatal("SetupExitCallback", "ThreadSafeFunction.BlockingCall() failed");
+    }
   });
 }
 
@@ -141,28 +153,60 @@ bool createDataServerPipe(bool write,
       /*dwOpenMode=*/winOpenMode,
       /*dwPipeMode=*/PIPE_TYPE_BYTE | PIPE_READMODE_BYTE | PIPE_WAIT,
       /*nMaxInstances=*/1,
-      /*nOutBufferSize=*/0,
-      /*nInBufferSize=*/0,
+      /*nOutBufferSize=*/128 * 1024,
+      /*nInBufferSize=*/128 * 1024,
       /*nDefaultTimeOut=*/30000,
       &sa);
 
   return *hServer != INVALID_HANDLE_VALUE;
 }
 
-HRESULT CreateNamedPipesAndPseudoConsole(COORD size,
+HANDLE LoadConptyDll(const Napi::CallbackInfo& info,
+                     const bool useConptyDll)
+{
+  if (!useConptyDll) {
+    return LoadLibraryExW(L"kernel32.dll", 0, 0);
+  }
+  wchar_t currentDir[MAX_PATH];
+  HMODULE hModule = GetModuleHandleA("conpty.node");
+  if (hModule == NULL) {
+    throw errorWithCode(info, "Failed to get conpty.node module handle");
+  }
+  DWORD result = GetModuleFileNameW(hModule, currentDir, MAX_PATH);
+  if (result == 0) {
+    throw errorWithCode(info, "Failed to get conpty.node module file name");
+  }
+  PathRemoveFileSpecW(currentDir);
+  wchar_t conptyDllPath[MAX_PATH];
+  PathCombineW(conptyDllPath, currentDir, L"conpty\\conpty.dll");
+  if (!path_util::file_exists(conptyDllPath)) {
+    std::wstring errorMessage = L"Cannot find conpty.dll at " + std::wstring(conptyDllPath);
+    std::string errorMessageStr = path_util::wstring_to_string(errorMessage);
+    throw errorWithCode(info, errorMessageStr.c_str());
+  }
+
+  return LoadLibraryW(conptyDllPath);
+}
+
+HRESULT CreateNamedPipesAndPseudoConsole(const Napi::CallbackInfo& info,
+                                         COORD size,
                                          DWORD dwFlags,
                                          HANDLE *phInput,
                                          HANDLE *phOutput,
                                          HPCON* phPC,
                                          std::wstring& inName,
                                          std::wstring& outName,
-                                         const std::wstring& pipeName)
+                                         const std::wstring& pipeName,
+                                         const bool useConptyDll)
 {
-  HANDLE hLibrary = LoadLibraryExW(L"kernel32.dll", 0, 0);
+  HANDLE hLibrary = LoadConptyDll(info, useConptyDll);
+  DWORD error = GetLastError();
   bool fLoadedDll = hLibrary != nullptr;
   if (fLoadedDll)
   {
-    PFNCREATEPSEUDOCONSOLE const pfnCreate = (PFNCREATEPSEUDOCONSOLE)GetProcAddress((HMODULE)hLibrary, "CreatePseudoConsole");
+    PFNCREATEPSEUDOCONSOLE const pfnCreate = (PFNCREATEPSEUDOCONSOLE)GetProcAddress(
+        (HMODULE)hLibrary,
+        useConptyDll ? "ConptyCreatePseudoConsole" : "CreatePseudoConsole");
     if (pfnCreate)
     {
       if (phPC == NULL || phInput == NULL || phOutput == NULL)
@@ -189,6 +233,8 @@ HRESULT CreateNamedPipesAndPseudoConsole(COORD size,
       //    We should fall back to winpty in this case.
       return HRESULT_FROM_WIN32(GetLastError());
     }
+  } else {
+    throw errorWithCode(info, "Failed to load conpty.dll");
   }
 
   // Failed to find  kernel32. This is realy unlikely - honestly no idea how
@@ -206,14 +252,15 @@ static Napi::Value PtyStartProcess(const Napi::CallbackInfo& info) {
   std::unique_ptr<wchar_t[]> mutableCommandline;
   PROCESS_INFORMATION _piClient{};
 
-  if (info.Length() != 6 ||
+  if (info.Length() != 7 ||
       !info[0].IsString() ||
       !info[1].IsNumber() ||
       !info[2].IsNumber() ||
       !info[3].IsBoolean() ||
       !info[4].IsString() ||
-      !info[5].IsBoolean()) {
-    throw Napi::Error::New(env, "Usage: pty.startProcess(file, cols, rows, debug, pipeName, inheritCursor)");
+      !info[5].IsBoolean() ||
+      !info[6].IsBoolean()) {
+    throw Napi::Error::New(env, "Usage: pty.startProcess(file, cols, rows, debug, pipeName, inheritCursor, useConptyDll)");
   }
 
   const std::wstring filename(path_util::to_wstring(info[0].As<Napi::String>()));
@@ -222,6 +269,7 @@ static Napi::Value PtyStartProcess(const Napi::CallbackInfo& info) {
   const bool debug = info[3].As<Napi::Boolean>().Value();
   const std::wstring pipeName(path_util::to_wstring(info[4].As<Napi::String>()));
   const bool inheritCursor = info[5].As<Napi::Boolean>().Value();
+  const bool useConptyDll = info[6].As<Napi::Boolean>().Value();
 
   // use environment 'Path' variable to determine location of
   // the relative path that we have recieved (e.g cmd.exe)
@@ -241,7 +289,7 @@ static Napi::Value PtyStartProcess(const Napi::CallbackInfo& info) {
 
   HANDLE hIn, hOut;
   HPCON hpc;
-  HRESULT hr = CreateNamedPipesAndPseudoConsole({cols, rows}, inheritCursor ? 1/*PSEUDOCONSOLE_INHERIT_CURSOR*/ : 0, &hIn, &hOut, &hpc, inName, outName, pipeName);
+  HRESULT hr = CreateNamedPipesAndPseudoConsole(info, {cols, rows}, inheritCursor ? 1/*PSEUDOCONSOLE_INHERIT_CURSOR*/ : 0, &hIn, &hOut, &hpc, inName, outName, pipeName, useConptyDll);
 
   // Restore default handling of ctrl+c
   SetConsoleCtrlHandler(NULL, FALSE);
@@ -252,8 +300,9 @@ static Napi::Value PtyStartProcess(const Napi::CallbackInfo& info) {
   if (SUCCEEDED(hr)) {
     // We were able to instantiate a conpty
     const int ptyId = InterlockedIncrement(&ptyCounter);
-    marshal.Set("pty", Napi::Number::New(env, ptyId));  
-    ptyHandles.insert(ptyHandles.end(), new pty_baton(ptyId, hIn, hOut, hpc));
+    marshal.Set("pty", Napi::Number::New(env, ptyId));
+    ptyHandles.emplace_back(
+        std::make_unique<pty_baton>(ptyId, hIn, hOut, hpc));
   } else {
     throw Napi::Error::New(env, "Cannot launch conpty");
   }
@@ -284,20 +333,22 @@ static Napi::Value PtyConnect(const Napi::CallbackInfo& info) {
   std::stringstream errorText;
   BOOL fSuccess = FALSE;
 
-  if (info.Length() != 5 ||
+  if (info.Length() != 6 ||
       !info[0].IsNumber() ||
       !info[1].IsString() ||
       !info[2].IsString() ||
       !info[3].IsArray() ||
-      !info[4].IsFunction()) {
-    throw Napi::Error::New(env, "Usage: pty.connect(id, cmdline, cwd, env, exitCallback)");
+      !info[4].IsBoolean() ||
+      !info[5].IsFunction()) {
+    throw Napi::Error::New(env, "Usage: pty.connect(id, cmdline, cwd, env, useConptyDll, exitCallback)");
   }
 
   const int id = info[0].As<Napi::Number>().Int32Value();
   const std::wstring cmdline(path_util::to_wstring(info[1].As<Napi::String>()));
   const std::wstring cwd(path_util::to_wstring(info[2].As<Napi::String>()));
   const Napi::Array envValues = info[3].As<Napi::Array>();
-  Napi::Function exitCallback = info[4].As<Napi::Function>();
+  const bool useConptyDll = info[4].As<Napi::Boolean>().Value();
+  Napi::Function exitCallback = info[5].As<Napi::Function>();
 
   // Fetch pty handle from ID and start process
   pty_baton* handle = get_pty_baton(id);
@@ -375,9 +426,27 @@ static Napi::Value PtyConnect(const Napi::CallbackInfo& info) {
     throw errorWithCode(info, "Cannot create process");
   }
 
+  HANDLE hLibrary = LoadConptyDll(info, useConptyDll);
+  bool fLoadedDll = hLibrary != nullptr;
+  if (useConptyDll && fLoadedDll)
+  {
+    PFNRELEASEPSEUDOCONSOLE const pfnReleasePseudoConsole = (PFNRELEASEPSEUDOCONSOLE)GetProcAddress(
+      (HMODULE)hLibrary, "ConptyReleasePseudoConsole");
+    if (pfnReleasePseudoConsole)
+    {
+      pfnReleasePseudoConsole(handle->hpc);
+    }
+  }
+
   // Update handle
   handle->hShell = piClient.hProcess;
 
+  // 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);
+
   SetupExitCallback(env, exitCallback, handle);
 
   // Return
@@ -390,25 +459,29 @@ static Napi::Value PtyResize(const Napi::CallbackInfo& info) {
   Napi::Env env(info.Env());
   Napi::HandleScope scope(env);
 
-  if (info.Length() != 3 ||
+  if (info.Length() != 4 ||
       !info[0].IsNumber() ||
       !info[1].IsNumber() ||
-      !info[2].IsNumber()) {
-    throw Napi::Error::New(env, "Usage: pty.resize(id, cols, rows)");
+      !info[2].IsNumber() ||
+      !info[3].IsBoolean()) {
+    throw Napi::Error::New(env, "Usage: pty.resize(id, cols, rows, useConptyDll)");
   }
 
   int id = info[0].As<Napi::Number>().Int32Value();
   SHORT cols = static_cast<SHORT>(info[1].As<Napi::Number>().Uint32Value());
   SHORT rows = static_cast<SHORT>(info[2].As<Napi::Number>().Uint32Value());
+  const bool useConptyDll = info[3].As<Napi::Boolean>().Value();
 
   const pty_baton* handle = get_pty_baton(id);
 
   if (handle != nullptr) {
-    HANDLE hLibrary = LoadLibraryExW(L"kernel32.dll", 0, 0);
+    HANDLE hLibrary = LoadConptyDll(info, useConptyDll);
     bool fLoadedDll = hLibrary != nullptr;
     if (fLoadedDll)
     {
-      PFNRESIZEPSEUDOCONSOLE const pfnResizePseudoConsole = (PFNRESIZEPSEUDOCONSOLE)GetProcAddress((HMODULE)hLibrary, "ResizePseudoConsole");
+      PFNRESIZEPSEUDOCONSOLE const pfnResizePseudoConsole = (PFNRESIZEPSEUDOCONSOLE)GetProcAddress(
+        (HMODULE)hLibrary,
+        useConptyDll ? "ConptyResizePseudoConsole" : "ResizePseudoConsole");
       if (pfnResizePseudoConsole)
       {
         COORD size = {cols, rows};
@@ -424,21 +497,30 @@ static Napi::Value PtyClear(const Napi::CallbackInfo& info) {
   Napi::Env env(info.Env());
   Napi::HandleScope scope(env);
 
-  if (info.Length() != 1 ||
-      !info[0].IsNumber()) {
-    throw Napi::Error::New(env, "Usage: pty.clear(id)");
+  if (info.Length() != 2 ||
+      !info[0].IsNumber() ||
+      !info[1].IsBoolean()) {
+    throw Napi::Error::New(env, "Usage: pty.clear(id, useConptyDll)");
   }
 
   int id = info[0].As<Napi::Number>().Int32Value();
+  const bool useConptyDll = info[1].As<Napi::Boolean>().Value();
+
+  // This API is only supported for conpty.dll as it was introduced in a later version of Windows.
+  // We could hook it up to point at >= a version of Windows only, but the future is conpty.dll
+  // anyway.
+  if (!useConptyDll) {
+    return env.Undefined();
+  }
 
   const pty_baton* handle = get_pty_baton(id);
 
   if (handle != nullptr) {
-    HANDLE hLibrary = LoadLibraryExW(L"kernel32.dll", 0, 0);
+    HANDLE hLibrary = LoadConptyDll(info, useConptyDll);
     bool fLoadedDll = hLibrary != nullptr;
     if (fLoadedDll)
     {
-      PFNCLEARPSEUDOCONSOLE const pfnClearPseudoConsole = (PFNCLEARPSEUDOCONSOLE)GetProcAddress((HMODULE)hLibrary, "ClearPseudoConsole");
+      PFNCLEARPSEUDOCONSOLE const pfnClearPseudoConsole = (PFNCLEARPSEUDOCONSOLE)GetProcAddress((HMODULE)hLibrary, "ConptyClearPseudoConsole");
       if (pfnClearPseudoConsole)
       {
         pfnClearPseudoConsole(handle->hpc);
@@ -453,29 +535,33 @@ static Napi::Value PtyKill(const Napi::CallbackInfo& info) {
   Napi::Env env(info.Env());
   Napi::HandleScope scope(env);
 
-  if (info.Length() != 1 ||
-      !info[0].IsNumber()) {
-    throw Napi::Error::New(env, "Usage: pty.kill(id)");
+  if (info.Length() != 2 ||
+      !info[0].IsNumber() ||
+      !info[1].IsBoolean()) {
+    throw Napi::Error::New(env, "Usage: pty.kill(id, useConptyDll)");
   }
 
   int id = info[0].As<Napi::Number>().Int32Value();
+  const bool useConptyDll = info[1].As<Napi::Boolean>().Value();
 
   const pty_baton* handle = get_pty_baton(id);
 
   if (handle != nullptr) {
-    HANDLE hLibrary = LoadLibraryExW(L"kernel32.dll", 0, 0);
+    HANDLE hLibrary = LoadConptyDll(info, useConptyDll);
     bool fLoadedDll = hLibrary != nullptr;
     if (fLoadedDll)
     {
-      PFNCLOSEPSEUDOCONSOLE const pfnClosePseudoConsole = (PFNCLOSEPSEUDOCONSOLE)GetProcAddress((HMODULE)hLibrary, "ClosePseudoConsole");
+      PFNCLOSEPSEUDOCONSOLE const pfnClosePseudoConsole = (PFNCLOSEPSEUDOCONSOLE)GetProcAddress(
+        (HMODULE)hLibrary,
+        useConptyDll ? "ConptyClosePseudoConsole" : "ClosePseudoConsole");
       if (pfnClosePseudoConsole)
       {
         pfnClosePseudoConsole(handle->hpc);
       }
     }
-
-    CloseHandle(handle->hShell);
-    assert(remove_pty_baton(id));
+    if (useConptyDll) {
+      TerminateProcess(handle->hShell, 1);
+    }
   }
 
   return env.Undefined();

package/src/win/conpty.h

@@ -0,0 +1,41 @@
+// Copyright (c) Microsoft Corporation.
+// Licensed under the MIT license.
+
+// This header prototypes the Pseudoconsole symbols from conpty.lib with their original names.
+// This is required because we cannot import __imp_CreatePseudoConsole from a static library
+// as it doesn't produce an import lib.
+// We can't use an /ALTERNATENAME trick because it seems that that name is only resolved when the
+// linker cannot otherwise find the symbol.
+
+#pragma once
+
+#include <consoleapi.h>
+
+#ifndef CONPTY_IMPEXP
+#define CONPTY_IMPEXP __declspec(dllimport)
+#endif
+
+#ifndef CONPTY_EXPORT
+#ifdef __cplusplus
+#define CONPTY_EXPORT extern "C" CONPTY_IMPEXP
+#else
+#define CONPTY_EXPORT extern CONPTY_IMPEXP
+#endif
+#endif
+
+#define PSEUDOCONSOLE_RESIZE_QUIRK (2u)
+#define PSEUDOCONSOLE_PASSTHROUGH_MODE (8u)
+
+CONPTY_EXPORT HRESULT WINAPI ConptyCreatePseudoConsole(COORD size, HANDLE hInput, HANDLE hOutput, DWORD dwFlags, HPCON* phPC);
+CONPTY_EXPORT HRESULT WINAPI ConptyCreatePseudoConsoleAsUser(HANDLE hToken, COORD size, HANDLE hInput, HANDLE hOutput, DWORD dwFlags, HPCON* phPC);
+
+CONPTY_EXPORT HRESULT WINAPI ConptyResizePseudoConsole(HPCON hPC, COORD size);
+CONPTY_EXPORT HRESULT WINAPI ConptyClearPseudoConsole(HPCON hPC);
+CONPTY_EXPORT HRESULT WINAPI ConptyShowHidePseudoConsole(HPCON hPC, bool show);
+CONPTY_EXPORT HRESULT WINAPI ConptyReparentPseudoConsole(HPCON hPC, HWND newParent);
+CONPTY_EXPORT HRESULT WINAPI ConptyReleasePseudoConsole(HPCON hPC);
+
+CONPTY_EXPORT VOID WINAPI ConptyClosePseudoConsole(HPCON hPC);
+CONPTY_EXPORT VOID WINAPI ConptyClosePseudoConsoleTimeout(HPCON hPC, DWORD dwMilliseconds);
+
+CONPTY_EXPORT HRESULT WINAPI ConptyPackPseudoConsole(HANDLE hServerProcess, HANDLE hRef, HANDLE hSignal, HPCON* phPC);

package/src/win/path_util.cc

@@ -58,38 +58,37 @@ std::wstring get_shell_path(std::wstring filename) {
     return shellpath;
   }
 
-  wchar_t buffer_[MAX_ENV];
+  wchar_t* buffer_ = new wchar_t[MAX_ENV];
   int read = ::GetEnvironmentVariableW(L"Path", buffer_, MAX_ENV);
-  if (!read) {
-    return shellpath;
-  }
-
-  std::wstring delimiter = L";";
-  size_t pos = 0;
-  std::vector<std::wstring> paths;
-  std::wstring buffer(buffer_);
-  while ((pos = buffer.find(delimiter)) != std::wstring::npos) {
-    paths.push_back(buffer.substr(0, pos));
-    buffer.erase(0, pos + delimiter.length());
-  }
+  if (read) {
+    std::wstring delimiter = L";";
+    size_t pos = 0;
+    std::vector<std::wstring> paths;
+    std::wstring buffer(buffer_);
+    while ((pos = buffer.find(delimiter)) != std::wstring::npos) {
+      paths.push_back(buffer.substr(0, pos));
+      buffer.erase(0, pos + delimiter.length());
+    }
 
-  const wchar_t *filename_ = filename.c_str();
+    const wchar_t *filename_ = filename.c_str();
 
-  for (size_t i = 0; i < paths.size(); ++i) {
-    std::wstring path = paths[i];
-    wchar_t searchPath[MAX_PATH];
-    ::PathCombineW(searchPath, const_cast<wchar_t*>(path.c_str()), filename_);
+    for (size_t i = 0; i < paths.size(); ++i) {
+      std::wstring path = paths[i];
+      wchar_t searchPath[MAX_PATH];
+      ::PathCombineW(searchPath, const_cast<wchar_t*>(path.c_str()), filename_);
 
-    if (searchPath == NULL) {
-      continue;
-    }
+      if (searchPath == NULL) {
+        continue;
+      }
 
-    if (file_exists(searchPath)) {
-      shellpath = searchPath;
-      break;
+      if (file_exists(searchPath)) {
+        shellpath = searchPath;
+        break;
+      }
     }
   }
 
+  delete[] buffer_;
   return shellpath;
 }
 

package/src/windowsConoutConnection.ts

@@ -37,9 +37,12 @@ export class ConoutConnection implements IDisposable {
   public get onReady(): IEvent<void> { return this._onReady.event; }
 
   constructor(
-    private _conoutPipeName: string
+    private _conoutPipeName: string,
+    private _useConptyDll: boolean
   ) {
-    const workerData: IWorkerData = { conoutPipeName: _conoutPipeName };
+    const workerData: IWorkerData = {
+      conoutPipeName: _conoutPipeName
+    };
     const scriptPath = __dirname.replace('node_modules.asar', 'node_modules.asar.unpacked');
     this._worker = new Worker(join(scriptPath, 'worker/conoutSocketWorker.js'), { workerData });
     this._worker.on('message', (message: ConoutWorkerMessage) => {
@@ -54,7 +57,7 @@ export class ConoutConnection implements IDisposable {
   }
 
   dispose(): void {
-    if (this._isDisposed) {
+    if (!this._useConptyDll && this._isDisposed) {
       return;
     }
     this._isDisposed = true;