node-pty 1.0.0 → 1.1.0-beta10

package/src/win/path_util.cc

@@ -4,18 +4,41 @@
  * Copyright (c) 2018, Microsoft Corporation (MIT License).
  */
 
-#include <nan.h>
+#include <stdexcept>
 #include <Shlwapi.h> // PathCombine
-
+#include <Windows.h>
 #include "path_util.h"
 
 namespace path_util {
 
-const wchar_t* to_wstring(const Nan::Utf8String& str) {
-  const char *bytes = *str;
-  unsigned int sizeOfStr = MultiByteToWideChar(CP_UTF8, 0, bytes, -1, NULL, 0);
-  wchar_t *output = new wchar_t[sizeOfStr];
-  MultiByteToWideChar(CP_UTF8, 0, bytes, -1, output, sizeOfStr);
+std::wstring to_wstring(const Napi::String& str) {
+  const std::u16string & u16 = str.Utf16Value();
+  return std::wstring(u16.begin(), u16.end());
+}
+
+std::string wstring_to_string(const std::wstring &wide_string) {
+  if (wide_string.empty()) {
+    return "";
+  }
+  const auto size_needed = WideCharToMultiByte(CP_UTF8, 0, &wide_string.at(0), (int)wide_string.size(), nullptr, 0, nullptr, nullptr);
+  if (size_needed <= 0) {
+    return "";
+  }
+  std::string result(size_needed, 0);
+  WideCharToMultiByte(CP_UTF8, 0, &wide_string.at(0), (int)wide_string.size(), &result.at(0), size_needed, nullptr, nullptr);
+  return result;
+}
+
+const char* from_wstring(const wchar_t* wstr) {
+  int bufferSize = WideCharToMultiByte(CP_UTF8, 0, wstr, -1, NULL, 0, NULL, NULL);
+  if (bufferSize <= 0) {
+    return "";
+  }
+  char *output = new char[bufferSize];
+  int status = WideCharToMultiByte(CP_UTF8, 0, wstr, -1, output, bufferSize, NULL, NULL);
+  if (status == 0) {
+    return "";
+  }
   return output;
 }
 

package/src/win/path_util.h

@@ -7,13 +7,17 @@
 #ifndef NODE_PTY_PATH_UTIL_H_
 #define NODE_PTY_PATH_UTIL_H_
 
-#include <nan.h>
+#define NODE_ADDON_API_DISABLE_DEPRECATED
+#include <napi.h>
+#include <string>
 
 #define MAX_ENV 65536
 
 namespace path_util {
 
-const wchar_t* to_wstring(const Nan::Utf8String& str);
+std::wstring to_wstring(const Napi::String& str);
+std::string wstring_to_string(const std::wstring &wide_string);
+const char* from_wstring(const wchar_t* wstr);
 bool file_exists(std::wstring filename);
 std::wstring get_shell_path(std::wstring filename);
 

package/src/win/winpty.cc

@@ -8,8 +8,11 @@
  *   with pseudo-terminal file descriptors.
  */
 
+#define NODE_ADDON_API_DISABLE_DEPRECATED
+#include <napi.h>
 #include <iostream>
-#include <nan.h>
+#include <assert.h>
+#include <map>
 #include <Shlwapi.h> // PathCombine, PathIsRelative
 #include <sstream>
 #include <stdlib.h>
@@ -23,8 +26,6 @@
 /**
 * Misc
 */
-extern "C" void init(v8::Local<v8::Object>);
-
 #define WINPTY_DBG_VARIABLE TEXT("WINPTYDBG")
 
 /**
@@ -37,21 +38,25 @@ static volatile LONG ptyCounter;
 * Helpers
 */
 
-static winpty_t *get_pipe_handle(int handle) {
+/** Keeps track of the handles created by PtyStartProcess */
+static std::map<DWORD, HANDLE> createdHandles;
+
+static winpty_t *get_pipe_handle(DWORD pid) {
   for (size_t i = 0; i < ptyHandles.size(); ++i) {
     winpty_t *ptyHandle = ptyHandles[i];
-    int current = (int)winpty_agent_process(ptyHandle);
-    if (current == handle) {
+    HANDLE current = winpty_agent_process(ptyHandle);
+    if (GetProcessId(current) == pid) {
       return ptyHandle;
     }
   }
   return nullptr;
 }
 
-static bool remove_pipe_handle(int handle) {
+static bool remove_pipe_handle(DWORD pid) {
   for (size_t i = 0; i < ptyHandles.size(); ++i) {
     winpty_t *ptyHandle = ptyHandles[i];
-    if ((int)winpty_agent_process(ptyHandle) == handle) {
+    HANDLE current = winpty_agent_process(ptyHandle);
+    if (GetProcessId(current) == pid) {
       winpty_free(ptyHandle);
       ptyHandles.erase(ptyHandles.begin() + i);
       ptyHandle = nullptr;
@@ -61,113 +66,117 @@ static bool remove_pipe_handle(int handle) {
   return false;
 }
 
-void throw_winpty_error(const char *generalMsg, winpty_error_ptr_t error_ptr) {
-  std::stringstream why;
-  std::wstring msg(winpty_error_msg(error_ptr));
-  std::string msg_(msg.begin(), msg.end());
-  why << generalMsg << ": " << msg_;
-  Nan::ThrowError(why.str().c_str());
+Napi::Error error_with_winpty_msg(const char *generalMsg, winpty_error_ptr_t error_ptr, Napi::Env env) {
+  std::string why;
+  why += generalMsg;
+  why += ": ";
+  why += path_util::wstring_to_string(winpty_error_msg(error_ptr));
   winpty_error_free(error_ptr);
+  return Napi::Error::New(env, why);
 }
 
-static NAN_METHOD(PtyGetExitCode) {
-  Nan::HandleScope scope;
+static Napi::Value PtyGetExitCode(const Napi::CallbackInfo& info) {
+  Napi::Env env(info.Env());
+  Napi::HandleScope scope(env);
 
   if (info.Length() != 1 ||
-      !info[0]->IsNumber()) {
-    Nan::ThrowError("Usage: pty.getExitCode(pidHandle)");
-    return;
+      !info[0].IsNumber()) {
+    throw Napi::Error::New(env, "Usage: pty.getExitCode(pid)");
+  }
+
+  DWORD pid = info[0].As<Napi::Number>().Uint32Value();
+  HANDLE handle = OpenProcess(PROCESS_QUERY_INFORMATION, FALSE, pid);
+  if (handle == NULL) {
+    return Napi::Number::New(env, -1);
   }
 
   DWORD exitCode = 0;
-  GetExitCodeProcess((HANDLE)info[0]->IntegerValue(Nan::GetCurrentContext()).FromJust(), &exitCode);
+  BOOL success = GetExitCodeProcess(handle, &exitCode);
+  if (success == FALSE) {
+    exitCode = -1;
+  }
 
-  info.GetReturnValue().Set(Nan::New<v8::Number>(exitCode));
+  CloseHandle(handle);
+  return Napi::Number::New(env, exitCode);
 }
 
-static NAN_METHOD(PtyGetProcessList) {
-  Nan::HandleScope scope;
+static Napi::Value PtyGetProcessList(const Napi::CallbackInfo& info) {
+  Napi::Env env(info.Env());
+  Napi::HandleScope scope(env);
 
   if (info.Length() != 1 ||
-      !info[0]->IsNumber()) {
-    Nan::ThrowError("Usage: pty.getProcessList(pid)");
-    return;
+      !info[0].IsNumber()) {
+    throw Napi::Error::New(env, "Usage: pty.getProcessList(pid)");
   }
 
-  int pid = info[0]->Int32Value(Nan::GetCurrentContext()).FromJust();
-
+  DWORD pid = info[0].As<Napi::Number>().Uint32Value();
   winpty_t *pc = get_pipe_handle(pid);
   if (pc == nullptr) {
-    info.GetReturnValue().Set(Nan::New<v8::Array>(0));
-    return;
+    return Napi::Number::New(env, 0);
   }
   int processList[64];
   const int processCount = 64;
   int actualCount = winpty_get_console_process_list(pc, processList, processCount, nullptr);
-
-  v8::Local<v8::Array> result = Nan::New<v8::Array>(actualCount);
-  for (uint32_t i = 0; i < actualCount; i++) {
-    Nan::Set(result, i, Nan::New<v8::Number>(processList[i]));
+  if (actualCount <= 0) {
+    return Napi::Number::New(env, 0);
+  }
+  Napi::Array result = Napi::Array::New(env, actualCount);
+  for (int i = 0; i < actualCount; i++) {
+    result.Set(i, Napi::Number::New(env, processList[i]));
   }
-  info.GetReturnValue().Set(result);
+  return result;
 }
 
-static NAN_METHOD(PtyStartProcess) {
-  Nan::HandleScope scope;
+static Napi::Value PtyStartProcess(const Napi::CallbackInfo& info) {
+  Napi::Env env(info.Env());
+  Napi::HandleScope scope(env);
 
   if (info.Length() != 7 ||
-      !info[0]->IsString() ||
-      !info[1]->IsString() ||
-      !info[2]->IsArray() ||
-      !info[3]->IsString() ||
-      !info[4]->IsNumber() ||
-      !info[5]->IsNumber() ||
-      !info[6]->IsBoolean()) {
-    Nan::ThrowError("Usage: pty.startProcess(file, cmdline, env, cwd, cols, rows, debug)");
-    return;
+      !info[0].IsString() ||
+      !info[1].IsString() ||
+      !info[2].IsArray() ||
+      !info[3].IsString() ||
+      !info[4].IsNumber() ||
+      !info[5].IsNumber() ||
+      !info[6].IsBoolean()) {
+    throw Napi::Error::New(env, "Usage: pty.startProcess(file, cmdline, env, cwd, cols, rows, debug)");
   }
 
-  std::stringstream why;
-
-  const wchar_t *filename = path_util::to_wstring(Nan::Utf8String(info[0]));
-  const wchar_t *cmdline = path_util::to_wstring(Nan::Utf8String(info[1]));
-  const wchar_t *cwd = path_util::to_wstring(Nan::Utf8String(info[3]));
+  std::wstring filename(path_util::to_wstring(info[0].As<Napi::String>()));
+  std::wstring cmdline(path_util::to_wstring(info[1].As<Napi::String>()));
+  std::wstring cwd(path_util::to_wstring(info[3].As<Napi::String>()));
 
   // create environment block
-  std::wstring env;
-  const v8::Local<v8::Array> envValues = v8::Local<v8::Array>::Cast(info[2]);
+  std::wstring envStr;
+  const Napi::Array envValues = info[2].As<Napi::Array>();
   if (!envValues.IsEmpty()) {
-
-    std::wstringstream envBlock;
-
-    for(uint32_t i = 0; i < envValues->Length(); i++) {
-      std::wstring envValue(path_util::to_wstring(Nan::Utf8String(Nan::Get(envValues, i).ToLocalChecked())));
-      envBlock << envValue << L'\0';
+    std::wstring envBlock;
+    for(uint32_t i = 0; i < envValues.Length(); i++) {
+      envBlock += path_util::to_wstring(envValues.Get(i).As<Napi::String>());
+      envBlock += L'\0';
     }
-
-    env = envBlock.str();
+    envStr = std::move(envBlock);
   }
 
   // use environment 'Path' variable to determine location of
   // the relative path that we have recieved (e.g cmd.exe)
   std::wstring shellpath;
-  if (::PathIsRelativeW(filename)) {
+  if (::PathIsRelativeW(filename.c_str())) {
     shellpath = path_util::get_shell_path(filename);
   } else {
     shellpath = filename;
   }
 
-  std::string shellpath_(shellpath.begin(), shellpath.end());
-
   if (shellpath.empty() || !path_util::file_exists(shellpath)) {
-    why << "File not found: " << shellpath_;
-    Nan::ThrowError(why.str().c_str());
-    goto cleanup;
+    std::string why;
+    why += "File not found: ";
+    why += path_util::wstring_to_string(shellpath);
+    throw Napi::Error::New(env, why);
   }
 
-  int cols = info[4]->Int32Value(Nan::GetCurrentContext()).FromJust();
-  int rows = info[5]->Int32Value(Nan::GetCurrentContext()).FromJust();
-  bool debug = Nan::To<bool>(info[6]).FromJust();
+  int cols = info[4].As<Napi::Number>().Int32Value();
+  int rows = info[5].As<Napi::Number>().Int32Value();
+  bool debug = info[6].As<Napi::Boolean>().Value();
 
   // Enable/disable debugging
   SetEnvironmentVariable(WINPTY_DBG_VARIABLE, debug ? "1" : NULL); // NULL = deletes variable
@@ -176,8 +185,7 @@ static NAN_METHOD(PtyStartProcess) {
   winpty_error_ptr_t error_ptr = nullptr;
   winpty_config_t* winpty_config = winpty_config_new(0, &error_ptr);
   if (winpty_config == nullptr) {
-    throw_winpty_error("Error creating WinPTY config", error_ptr);
-    goto cleanup;
+    throw error_with_winpty_msg("Error creating WinPTY config", error_ptr, env);
   }
   winpty_error_free(error_ptr);
 
@@ -188,19 +196,15 @@ static NAN_METHOD(PtyStartProcess) {
   winpty_t *pc = winpty_open(winpty_config, &error_ptr);
   winpty_config_free(winpty_config);
   if (pc == nullptr) {
-    throw_winpty_error("Error launching WinPTY agent", error_ptr);
-    goto cleanup;
+    throw error_with_winpty_msg("Error launching WinPTY agent", error_ptr, env);
   }
   winpty_error_free(error_ptr);
 
-  // Save pty struct for later use
-  ptyHandles.insert(ptyHandles.end(), pc);
-
   // Create winpty spawn config
-  winpty_spawn_config_t* config = winpty_spawn_config_new(WINPTY_SPAWN_FLAG_AUTO_SHUTDOWN, shellpath.c_str(), cmdline, cwd, env.c_str(), &error_ptr);
+  winpty_spawn_config_t* config = winpty_spawn_config_new(WINPTY_SPAWN_FLAG_AUTO_SHUTDOWN, shellpath.c_str(), cmdline.c_str(), cwd.c_str(), envStr.c_str(), &error_ptr);
   if (config == nullptr) {
-    throw_winpty_error("Error creating WinPTY spawn config", error_ptr);
-    goto cleanup;
+    winpty_free(pc);
+    throw error_with_winpty_msg("Error creating WinPTY spawn config", error_ptr, env);
   }
   winpty_error_free(error_ptr);
 
@@ -209,104 +213,121 @@ static NAN_METHOD(PtyStartProcess) {
   BOOL spawnSuccess = winpty_spawn(pc, config, &handle, nullptr, nullptr, &error_ptr);
   winpty_spawn_config_free(config);
   if (!spawnSuccess) {
-    throw_winpty_error("Unable to start terminal process", error_ptr);
-    goto cleanup;
+    if (handle) {
+      CloseHandle(handle);
+    }
+    winpty_free(pc);
+    throw error_with_winpty_msg("Unable to start terminal process", error_ptr, env);
   }
   winpty_error_free(error_ptr);
 
-  // Set return values
-  v8::Local<v8::Object> marshal = Nan::New<v8::Object>();
-  Nan::Set(marshal, Nan::New<v8::String>("innerPid").ToLocalChecked(), Nan::New<v8::Number>((int)GetProcessId(handle)));
-  Nan::Set(marshal, Nan::New<v8::String>("innerPidHandle").ToLocalChecked(), Nan::New<v8::Number>((int)handle));
-  Nan::Set(marshal, Nan::New<v8::String>("pid").ToLocalChecked(), Nan::New<v8::Number>((int)winpty_agent_process(pc)));
-  Nan::Set(marshal, Nan::New<v8::String>("pty").ToLocalChecked(), Nan::New<v8::Number>(InterlockedIncrement(&ptyCounter)));
-  Nan::Set(marshal, Nan::New<v8::String>("fd").ToLocalChecked(), Nan::New<v8::Number>(-1));
-  {
-    LPCWSTR coninPipeName = winpty_conin_name(pc);
-    std::wstring coninPipeNameWStr(coninPipeName);
-    std::string coninPipeNameStr(coninPipeNameWStr.begin(), coninPipeNameWStr.end());
-    Nan::Set(marshal, Nan::New<v8::String>("conin").ToLocalChecked(), Nan::New<v8::String>(coninPipeNameStr).ToLocalChecked());
-    LPCWSTR conoutPipeName = winpty_conout_name(pc);
-    std::wstring conoutPipeNameWStr(conoutPipeName);
-    std::string conoutPipeNameStr(conoutPipeNameWStr.begin(), conoutPipeNameWStr.end());
-    Nan::Set(marshal, Nan::New<v8::String>("conout").ToLocalChecked(), Nan::New<v8::String>(conoutPipeNameStr).ToLocalChecked());
+  LPCWSTR coninPipeName = winpty_conin_name(pc);
+  std::string coninPipeNameStr(path_util::from_wstring(coninPipeName));
+  if (coninPipeNameStr.empty()) {
+    CloseHandle(handle);
+    winpty_free(pc);
+    throw Napi::Error::New(env, "Failed to initialize winpty conin");
   }
-  info.GetReturnValue().Set(marshal);
 
-  goto cleanup;
+  LPCWSTR conoutPipeName = winpty_conout_name(pc);
+  std::string conoutPipeNameStr(path_util::from_wstring(conoutPipeName));
+  if (conoutPipeNameStr.empty()) {
+    CloseHandle(handle);
+    winpty_free(pc);
+    throw Napi::Error::New(env, "Failed to initialize winpty conout");
+  }
 
-cleanup:
-  delete filename;
-  delete cmdline;
-  delete cwd;
+  DWORD innerPid = GetProcessId(handle);
+  if (createdHandles[innerPid]) {
+    CloseHandle(handle);
+    winpty_free(pc);
+    std::stringstream why;
+    why << "There is already a process with innerPid " << innerPid;
+    throw Napi::Error::New(env, why.str());
+  }
+  createdHandles[innerPid] = handle;
+
+  // Save pty struct for later use
+  ptyHandles.push_back(pc);
+
+  DWORD pid = GetProcessId(winpty_agent_process(pc));
+  Napi::Object marshal = Napi::Object::New(env);
+  marshal.Set("innerPid", Napi::Number::New(env, (int)innerPid));
+  marshal.Set("pid", Napi::Number::New(env, (int)pid));
+  marshal.Set("pty", Napi::Number::New(env, InterlockedIncrement(&ptyCounter)));
+  marshal.Set("fd", Napi::Number::New(env, -1));
+  marshal.Set("conin", Napi::String::New(env, coninPipeNameStr));
+  marshal.Set("conout", Napi::String::New(env, conoutPipeNameStr));
+
+  return marshal;
 }
 
-static NAN_METHOD(PtyResize) {
-  Nan::HandleScope scope;
+static Napi::Value PtyResize(const Napi::CallbackInfo& info) {
+  Napi::Env env(info.Env());
+  Napi::HandleScope scope(env);
 
   if (info.Length() != 3 ||
-      !info[0]->IsNumber() ||
-      !info[1]->IsNumber() ||
-      !info[2]->IsNumber()) {
-    Nan::ThrowError("Usage: pty.resize(pid, cols, rows)");
-    return;
+      !info[0].IsNumber() ||
+      !info[1].IsNumber() ||
+      !info[2].IsNumber()) {
+    throw Napi::Error::New(env, "Usage: pty.resize(pid, cols, rows)");
   }
 
-  int handle = info[0]->Int32Value(Nan::GetCurrentContext()).FromJust();
-  int cols = info[1]->Int32Value(Nan::GetCurrentContext()).FromJust();
-  int rows = info[2]->Int32Value(Nan::GetCurrentContext()).FromJust();
+  DWORD pid = info[0].As<Napi::Number>().Uint32Value();
+  int cols = info[1].As<Napi::Number>().Int32Value();
+  int rows = info[2].As<Napi::Number>().Int32Value();
 
-  winpty_t *pc = get_pipe_handle(handle);
+  winpty_t *pc = get_pipe_handle(pid);
 
   if (pc == nullptr) {
-    Nan::ThrowError("The pty doesn't appear to exist");
-    return;
+    throw Napi::Error::New(env, "The pty doesn't appear to exist");
   }
   BOOL success = winpty_set_size(pc, cols, rows, nullptr);
   if (!success) {
-    Nan::ThrowError("The pty could not be resized");
-    return;
+    throw Napi::Error::New(env, "The pty could not be resized");
   }
 
-  return info.GetReturnValue().SetUndefined();
+  return env.Undefined();
 }
 
-static NAN_METHOD(PtyKill) {
-  Nan::HandleScope scope;
+static Napi::Value PtyKill(const Napi::CallbackInfo& info) {
+  Napi::Env env(info.Env());
+  Napi::HandleScope scope(env);
 
   if (info.Length() != 2 ||
-      !info[0]->IsNumber() ||
-      !info[1]->IsNumber()) {
-    Nan::ThrowError("Usage: pty.kill(pid, innerPidHandle)");
-    return;
+      !info[0].IsNumber() ||
+      !info[1].IsNumber()) {
+    throw Napi::Error::New(env, "Usage: pty.kill(pid, innerPid)");
   }
 
-  int handle = info[0]->Int32Value(Nan::GetCurrentContext()).FromJust();
-  HANDLE innerPidHandle = (HANDLE)info[1]->Int32Value(Nan::GetCurrentContext()).FromJust();
+  DWORD pid = info[0].As<Napi::Number>().Uint32Value();
+  DWORD innerPid = info[1].As<Napi::Number>().Uint32Value();
 
-  winpty_t *pc = get_pipe_handle(handle);
+  winpty_t *pc = get_pipe_handle(pid);
   if (pc == nullptr) {
-    Nan::ThrowError("Pty seems to have been killed already");
-    return;
+    throw Napi::Error::New(env, "Pty seems to have been killed already");
   }
 
-  assert(remove_pipe_handle(handle));
+  assert(remove_pipe_handle(pid));
+
+  HANDLE innerPidHandle = createdHandles[innerPid];
+  createdHandles.erase(innerPid);
   CloseHandle(innerPidHandle);
 
-  return info.GetReturnValue().SetUndefined();
+  return env.Undefined();
 }
 
 /**
 * Init
 */
 
-extern "C" void init(v8::Local<v8::Object> target) {
-  Nan::HandleScope scope;
-  Nan::SetMethod(target, "startProcess", PtyStartProcess);
-  Nan::SetMethod(target, "resize", PtyResize);
-  Nan::SetMethod(target, "kill", PtyKill);
-  Nan::SetMethod(target, "getExitCode", PtyGetExitCode);
-  Nan::SetMethod(target, "getProcessList", PtyGetProcessList);
+Napi::Object init(Napi::Env env, Napi::Object exports) {
+  exports.Set("startProcess", Napi::Function::New(env, PtyStartProcess));
+  exports.Set("resize", Napi::Function::New(env, PtyResize));
+  exports.Set("kill", Napi::Function::New(env, PtyKill));
+  exports.Set("getExitCode", Napi::Function::New(env, PtyGetExitCode));
+  exports.Set("getProcessList", Napi::Function::New(env, PtyGetProcessList));
+  return exports;
 };
 
-NODE_MODULE(pty, init);
+NODE_API_MODULE(NODE_GYP_MODULE_NAME, init);

package/src/windowsPtyAgent.ts

@@ -31,7 +31,6 @@ export class WindowsPtyAgent {
   private _outSocket: Socket;
   private _pid: number = 0;
   private _innerPid: number = 0;
-  private _innerPidHandle: number = 0;
   private _closeTimeout: NodeJS.Timer | undefined;
   private _exitCode: number | undefined;
   private _conoutSocketWorker: ConoutConnection;
@@ -105,7 +104,6 @@ export class WindowsPtyAgent {
       term = (this._ptyNative as IWinptyNative).startProcess(file, commandLine, env, cwd, cols, rows, debug);
       this._pid = (term as IWinptyProcess).pid;
       this._innerPid = (term as IWinptyProcess).innerPid;
-      this._innerPidHandle = (term as IWinptyProcess).innerPidHandle;
     }
 
     // Not available on windows.
@@ -174,14 +172,14 @@ export class WindowsPtyAgent {
         (this._ptyNative as IConptyNative).kill(this._pty);
       });
     } else {
-      (this._ptyNative as IWinptyNative).kill(this._pid, this._innerPidHandle);
-      // Since pty.kill closes the handle it will kill most processes by itself
-      // and process IDs can be reused as soon as all handles to them are
-      // dropped, we want to immediately kill the entire console process list.
+      // Because pty.kill closes the handle, it will kill most processes by itself.
+      // Process IDs can be reused as soon as all handles to them are
+      // dropped, so we want to immediately kill the entire console process list.
       // If we do not force kill all processes here, node servers in particular
       // seem to become detached and remain running (see
       // Microsoft/vscode#26807).
       const processList: number[] = (this._ptyNative as IWinptyNative).getProcessList(this._pid);
+      (this._ptyNative as IWinptyNative).kill(this._pid, this._innerPid);
       processList.forEach(pid => {
         try {
           process.kill(pid);
@@ -212,7 +210,8 @@ export class WindowsPtyAgent {
     if (this._useConpty) {
       return this._exitCode;
     }
-    return (this._ptyNative as IWinptyNative).getExitCode(this._innerPidHandle);
+    const winptyExitCode = (this._ptyNative as IWinptyNative).getExitCode(this._innerPid);
+    return winptyExitCode === -1 ? undefined : winptyExitCode;
   }
 
   private _getWindowsBuildNumber(): number {