Add original files from the node-pty project

Taken from <https://github.com/microsoft/node-pty>.
See the LICENSE.md file added in this commit for license and copyright
information.

addons/godot_xterm/native/src/node_pty/win/conpty.cc

@@ -0,0 +1,455 @@
+/**
+ * Copyright (c) 2013-2015, Christopher Jeffrey, Peter Sunde (MIT License)
+ * Copyright (c) 2016, Daniel Imms (MIT License).
+ * Copyright (c) 2018, Microsoft Corporation (MIT License).
+ *
+ * pty.cc:
+ *   This file is responsible for starting processes
+ *   with pseudo-terminal file descriptors.
+ */
+
+// node versions lower than 10 define this as 0x502 which disables many of the definitions needed to compile
+#include <node_version.h>
+#if NODE_MODULE_VERSION <= 57
+  #define _WIN32_WINNT 0x600
+#endif
+
+#include <iostream>
+#include <nan.h>
+#include <Shlwapi.h> // PathCombine, PathIsRelative
+#include <sstream>
+#include <string>
+#include <vector>
+#include <Windows.h>
+#include <strsafe.h>
+#include "path_util.h"
+
+extern "C" void init(v8::Local<v8::Object>);
+
+// Taken from the RS5 Windows SDK, but redefined here in case we're targeting <= 17134
+#ifndef PROC_THREAD_ATTRIBUTE_PSEUDOCONSOLE
+#define PROC_THREAD_ATTRIBUTE_PSEUDOCONSOLE \
+  ProcThreadAttributeValue(22, FALSE, TRUE, FALSE)
+
+typedef VOID* HPCON;
+typedef HRESULT (__stdcall *PFNCREATEPSEUDOCONSOLE)(COORD c, HANDLE hIn, HANDLE hOut, DWORD dwFlags, HPCON* phpcon);
+typedef HRESULT (__stdcall *PFNRESIZEPSEUDOCONSOLE)(HPCON hpc, COORD newSize);
+typedef void (__stdcall *PFNCLOSEPSEUDOCONSOLE)(HPCON hpc);
+
+#endif
+
+struct pty_baton {
+  int id;
+  HANDLE hIn;
+  HANDLE hOut;
+  HPCON hpc;
+
+  HANDLE hShell;
+  HANDLE hWait;
+  Nan::Callback cb;
+  uv_async_t async;
+  uv_thread_t tid;
+
+  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 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;
+    }
+  }
+  return nullptr;
+}
+
+template <typename T>
+std::vector<T> vectorFromString(const std::basic_string<T> &str) {
+    return std::vector<T>(str.begin(), str.end());
+}
+
+void throwNanError(const Nan::FunctionCallbackInfo<v8::Value>* info, const char* text, const bool getLastError) {
+  std::stringstream errorText;
+  errorText << text;
+  if (getLastError) {
+    errorText << ", error code: " << GetLastError();
+  }
+  Nan::ThrowError(errorText.str().c_str());
+  (*info).GetReturnValue().SetUndefined();
+}
+
+// Returns a new server named pipe.  It has not yet been connected.
+bool createDataServerPipe(bool write,
+                          std::wstring kind,
+                          HANDLE* hServer,
+                          std::wstring &name,
+                          const std::wstring &pipeName)
+{
+  *hServer = INVALID_HANDLE_VALUE;
+
+  name = L"\\\\.\\pipe\\" + pipeName + L"-" + kind;
+
+  const DWORD winOpenMode =  PIPE_ACCESS_INBOUND | PIPE_ACCESS_OUTBOUND | FILE_FLAG_FIRST_PIPE_INSTANCE/*  | FILE_FLAG_OVERLAPPED */;
+
+  SECURITY_ATTRIBUTES sa = {};
+  sa.nLength = sizeof(sa);
+
+  *hServer = CreateNamedPipeW(
+      name.c_str(),
+      /*dwOpenMode=*/winOpenMode,
+      /*dwPipeMode=*/PIPE_TYPE_BYTE | PIPE_READMODE_BYTE | PIPE_WAIT,
+      /*nMaxInstances=*/1,
+      /*nOutBufferSize=*/0,
+      /*nInBufferSize=*/0,
+      /*nDefaultTimeOut=*/30000,
+      &sa);
+
+  return *hServer != INVALID_HANDLE_VALUE;
+}
+
+HRESULT CreateNamedPipesAndPseudoConsole(COORD size,
+                                         DWORD dwFlags,
+                                         HANDLE *phInput,
+                                         HANDLE *phOutput,
+                                         HPCON* phPC,
+                                         std::wstring& inName,
+                                         std::wstring& outName,
+                                         const std::wstring& pipeName)
+{
+  HANDLE hLibrary = LoadLibraryExW(L"kernel32.dll", 0, 0);
+  bool fLoadedDll = hLibrary != nullptr;
+  if (fLoadedDll)
+  {
+    PFNCREATEPSEUDOCONSOLE const pfnCreate = (PFNCREATEPSEUDOCONSOLE)GetProcAddress((HMODULE)hLibrary, "CreatePseudoConsole");
+    if (pfnCreate)
+    {
+      if (phPC == NULL || phInput == NULL || phOutput == NULL)
+      {
+        return E_INVALIDARG;
+      }
+
+      bool success = createDataServerPipe(true, L"in", phInput, inName, pipeName);
+      if (!success)
+      {
+        return HRESULT_FROM_WIN32(GetLastError());
+      }
+      success = createDataServerPipe(false, L"out", phOutput, outName, pipeName);
+      if (!success)
+      {
+        return HRESULT_FROM_WIN32(GetLastError());
+      }
+      return pfnCreate(size, *phInput, *phOutput, dwFlags, phPC);
+    }
+    else
+    {
+      // Failed to find CreatePseudoConsole in kernel32. This is likely because
+      //    the user is not running a build of Windows that supports that API.
+      //    We should fall back to winpty in this case.
+      return HRESULT_FROM_WIN32(GetLastError());
+    }
+  }
+
+  // Failed to find  kernel32. This is realy unlikely - honestly no idea how
+  //    this is even possible to hit. But if it does happen, fall back to winpty.
+  return HRESULT_FROM_WIN32(GetLastError());
+}
+
+static NAN_METHOD(PtyStartProcess) {
+  Nan::HandleScope scope;
+
+  v8::Local<v8::Object> marshal;
+  std::wstring inName, outName;
+  BOOL fSuccess = FALSE;
+  std::unique_ptr<wchar_t[]> mutableCommandline;
+  PROCESS_INFORMATION _piClient{};
+
+  if (info.Length() != 6 ||
+      !info[0]->IsString() ||
+      !info[1]->IsNumber() ||
+      !info[2]->IsNumber() ||
+      !info[3]->IsBoolean() ||
+      !info[4]->IsString() ||
+      !info[5]->IsBoolean()) {
+    Nan::ThrowError("Usage: pty.startProcess(file, cols, rows, debug, pipeName, inheritCursor)");
+    return;
+  }
+
+  const std::wstring filename(path_util::to_wstring(Nan::Utf8String(info[0])));
+  const SHORT cols = info[1]->Uint32Value(Nan::GetCurrentContext()).FromJust();
+  const SHORT rows = info[2]->Uint32Value(Nan::GetCurrentContext()).FromJust();
+  const bool debug = Nan::To<bool>(info[3]).FromJust();
+  const std::wstring pipeName(path_util::to_wstring(Nan::Utf8String(info[4])));
+  const bool inheritCursor = Nan::To<bool>(info[5]).FromJust();
+
+  // 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.c_str())) {
+    shellpath = path_util::get_shell_path(filename.c_str());
+  } else {
+    shellpath = filename;
+  }
+
+  std::string shellpath_(shellpath.begin(), shellpath.end());
+
+  if (shellpath.empty() || !path_util::file_exists(shellpath)) {
+    std::stringstream why;
+    why << "File not found: " << shellpath_;
+    Nan::ThrowError(why.str().c_str());
+    return;
+  }
+
+  HANDLE hIn, hOut;
+  HPCON hpc;
+  HRESULT hr = CreateNamedPipesAndPseudoConsole({cols, rows}, inheritCursor ? 1/*PSEUDOCONSOLE_INHERIT_CURSOR*/ : 0, &hIn, &hOut, &hpc, inName, outName, pipeName);
+
+  // Restore default handling of ctrl+c
+  SetConsoleCtrlHandler(NULL, FALSE);
+
+  // Set return values
+  marshal = Nan::New<v8::Object>();
+
+  if (SUCCEEDED(hr)) {
+    // We were able to instantiate a conpty
+    const int ptyId = InterlockedIncrement(&ptyCounter);
+    Nan::Set(marshal, Nan::New<v8::String>("pty").ToLocalChecked(), Nan::New<v8::Number>(ptyId));
+    ptyHandles.insert(ptyHandles.end(), new pty_baton(ptyId, hIn, hOut, hpc));
+  } else {
+    Nan::ThrowError("Cannot launch conpty");
+    return;
+  }
+
+  Nan::Set(marshal, Nan::New<v8::String>("fd").ToLocalChecked(), Nan::New<v8::Number>(-1));
+  {
+    std::string coninPipeNameStr(inName.begin(), inName.end());
+    Nan::Set(marshal, Nan::New<v8::String>("conin").ToLocalChecked(), Nan::New<v8::String>(coninPipeNameStr).ToLocalChecked());
+
+    std::string conoutPipeNameStr(outName.begin(), outName.end());
+    Nan::Set(marshal, Nan::New<v8::String>("conout").ToLocalChecked(), Nan::New<v8::String>(conoutPipeNameStr).ToLocalChecked());
+  }
+  info.GetReturnValue().Set(marshal);
+}
+
+VOID CALLBACK OnProcessExitWinEvent(
+    _In_ PVOID context,
+    _In_ BOOLEAN TimerOrWaitFired) {
+  pty_baton *baton = static_cast<pty_baton*>(context);
+
+  // Fire OnProcessExit
+  uv_async_send(&baton->async);
+}
+
+static void OnProcessExit(uv_async_t *async) {
+  Nan::HandleScope scope;
+  pty_baton *baton = static_cast<pty_baton*>(async->data);
+
+  UnregisterWait(baton->hWait);
+
+  // Get exit code
+  DWORD exitCode = 0;
+  GetExitCodeProcess(baton->hShell, &exitCode);
+
+  // Call function
+  v8::Local<v8::Value> args[1] = {
+    Nan::New<v8::Number>(exitCode)
+  };
+
+  Nan::AsyncResource asyncResource("node-pty.callback");
+  baton->cb.Call(1, args, &asyncResource);
+  // Clean up
+  baton->cb.Reset();
+}
+
+static NAN_METHOD(PtyConnect) {
+  Nan::HandleScope scope;
+
+  // If we're working with conpty's we need to call ConnectNamedPipe here AFTER
+  //    the Socket has attempted to connect to the other end, then actually
+  //    spawn the process here.
+
+  std::stringstream errorText;
+  BOOL fSuccess = FALSE;
+
+  if (info.Length() != 5 ||
+      !info[0]->IsNumber() ||
+      !info[1]->IsString() ||
+      !info[2]->IsString() ||
+      !info[3]->IsArray() ||
+      !info[4]->IsFunction()) {
+    Nan::ThrowError("Usage: pty.connect(id, cmdline, cwd, env, exitCallback)");
+    return;
+  }
+
+  const int id = info[0]->Int32Value(Nan::GetCurrentContext()).FromJust();
+  const std::wstring cmdline(path_util::to_wstring(Nan::Utf8String(info[1])));
+  const std::wstring cwd(path_util::to_wstring(Nan::Utf8String(info[2])));
+  const v8::Local<v8::Array> envValues = info[3].As<v8::Array>();
+  const v8::Local<v8::Function> exitCallback = v8::Local<v8::Function>::Cast(info[4]);
+
+  // Prepare command line
+  std::unique_ptr<wchar_t[]> mutableCommandline = std::make_unique<wchar_t[]>(cmdline.length() + 1);
+  HRESULT hr = StringCchCopyW(mutableCommandline.get(), cmdline.length() + 1, cmdline.c_str());
+
+  // Prepare cwd
+  std::unique_ptr<wchar_t[]> mutableCwd = std::make_unique<wchar_t[]>(cwd.length() + 1);
+  hr = StringCchCopyW(mutableCwd.get(), cwd.length() + 1, cwd.c_str());
+
+  // Prepare environment
+  std::wstring env;
+  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';
+    }
+    envBlock << L'\0';
+    env = envBlock.str();
+  }
+  auto envV = vectorFromString(env);
+  LPWSTR envArg = envV.empty() ? nullptr : envV.data();
+
+  // Fetch pty handle from ID and start process
+  pty_baton* handle = get_pty_baton(id);
+
+  BOOL success = ConnectNamedPipe(handle->hIn, nullptr);
+  success = ConnectNamedPipe(handle->hOut, nullptr);
+
+  // Attach the pseudoconsole to the client application we're creating
+  STARTUPINFOEXW siEx{0};
+  siEx.StartupInfo.cb = sizeof(STARTUPINFOEXW);
+  siEx.StartupInfo.dwFlags |= STARTF_USESTDHANDLES;
+  siEx.StartupInfo.hStdError = nullptr;
+  siEx.StartupInfo.hStdInput = nullptr;
+  siEx.StartupInfo.hStdOutput = nullptr;
+
+  SIZE_T size = 0;
+  InitializeProcThreadAttributeList(NULL, 1, 0, &size);
+  BYTE *attrList = new BYTE[size];
+  siEx.lpAttributeList = reinterpret_cast<PPROC_THREAD_ATTRIBUTE_LIST>(attrList);
+
+  fSuccess = InitializeProcThreadAttributeList(siEx.lpAttributeList, 1, 0, &size);
+  if (!fSuccess) {
+    return throwNanError(&info, "InitializeProcThreadAttributeList failed", true);
+  }
+  fSuccess = UpdateProcThreadAttribute(siEx.lpAttributeList,
+                                       0,
+                                       PROC_THREAD_ATTRIBUTE_PSEUDOCONSOLE,
+                                       handle->hpc,
+                                       sizeof(HPCON),
+                                       NULL,
+                                       NULL);
+  if (!fSuccess) {
+    return throwNanError(&info, "UpdateProcThreadAttribute failed", true);
+  }
+
+  PROCESS_INFORMATION piClient{};
+  fSuccess = !!CreateProcessW(
+      nullptr,
+      mutableCommandline.get(),
+      nullptr,                      // lpProcessAttributes
+      nullptr,                      // lpThreadAttributes
+      false,                        // bInheritHandles VERY IMPORTANT that this is false
+      EXTENDED_STARTUPINFO_PRESENT | CREATE_UNICODE_ENVIRONMENT, // dwCreationFlags
+      envArg,                       // lpEnvironment
+      mutableCwd.get(),             // lpCurrentDirectory
+      &siEx.StartupInfo,            // lpStartupInfo
+      &piClient                     // lpProcessInformation
+  );
+  if (!fSuccess) {
+    return throwNanError(&info, "Cannot create process", true);
+  }
+
+  // Update handle
+  handle->hShell = piClient.hProcess;
+  handle->cb.Reset(exitCallback);
+  handle->async.data = handle;
+
+  // Setup OnProcessExit callback
+  uv_async_init(uv_default_loop(), &handle->async, OnProcessExit);
+
+  // Setup Windows wait for process exit event
+  RegisterWaitForSingleObject(&handle->hWait, piClient.hProcess, OnProcessExitWinEvent, (PVOID)handle, INFINITE, WT_EXECUTEONLYONCE);
+
+  // Return
+  v8::Local<v8::Object> marshal = Nan::New<v8::Object>();
+  Nan::Set(marshal, Nan::New<v8::String>("pid").ToLocalChecked(), Nan::New<v8::Number>(piClient.dwProcessId));
+  info.GetReturnValue().Set(marshal);
+}
+
+static NAN_METHOD(PtyResize) {
+  Nan::HandleScope scope;
+
+  if (info.Length() != 3 ||
+      !info[0]->IsNumber() ||
+      !info[1]->IsNumber() ||
+      !info[2]->IsNumber()) {
+    Nan::ThrowError("Usage: pty.resize(id, cols, rows)");
+    return;
+  }
+
+  int id = info[0]->Int32Value(Nan::GetCurrentContext()).FromJust();
+  SHORT cols = info[1]->Uint32Value(Nan::GetCurrentContext()).FromJust();
+  SHORT rows = info[2]->Uint32Value(Nan::GetCurrentContext()).FromJust();
+
+  const pty_baton* handle = get_pty_baton(id);
+
+  HANDLE hLibrary = LoadLibraryExW(L"kernel32.dll", 0, 0);
+  bool fLoadedDll = hLibrary != nullptr;
+  if (fLoadedDll)
+  {
+    PFNRESIZEPSEUDOCONSOLE const pfnResizePseudoConsole = (PFNRESIZEPSEUDOCONSOLE)GetProcAddress((HMODULE)hLibrary, "ResizePseudoConsole");
+    if (pfnResizePseudoConsole)
+    {
+      COORD size = {cols, rows};
+      pfnResizePseudoConsole(handle->hpc, size);
+    }
+  }
+
+  return info.GetReturnValue().SetUndefined();
+}
+
+static NAN_METHOD(PtyKill) {
+  Nan::HandleScope scope;
+
+  if (info.Length() != 1 ||
+      !info[0]->IsNumber()) {
+    Nan::ThrowError("Usage: pty.kill(id)");
+    return;
+  }
+
+  int id = info[0]->Int32Value(Nan::GetCurrentContext()).FromJust();
+
+  const pty_baton* handle = get_pty_baton(id);
+
+  HANDLE hLibrary = LoadLibraryExW(L"kernel32.dll", 0, 0);
+  bool fLoadedDll = hLibrary != nullptr;
+  if (fLoadedDll)
+  {
+    PFNCLOSEPSEUDOCONSOLE const pfnClosePseudoConsole = (PFNCLOSEPSEUDOCONSOLE)GetProcAddress((HMODULE)hLibrary, "ClosePseudoConsole");
+    if (pfnClosePseudoConsole)
+    {
+      pfnClosePseudoConsole(handle->hpc);
+    }
+  }
+
+  CloseHandle(handle->hShell);
+
+  return info.GetReturnValue().SetUndefined();
+}
+
+/**
+* Init
+*/
+
+extern "C" void init(v8::Local<v8::Object> target) {
+  Nan::HandleScope scope;
+  Nan::SetMethod(target, "startProcess", PtyStartProcess);
+  Nan::SetMethod(target, "connect", PtyConnect);
+  Nan::SetMethod(target, "resize", PtyResize);
+  Nan::SetMethod(target, "kill", PtyKill);
+};
+
+NODE_MODULE(pty, init);

addons/godot_xterm/native/src/node_pty/win/conpty_console_list.cc

@@ -0,0 +1,43 @@
+/**
+ * Copyright (c) 2019, Microsoft Corporation (MIT License).
+ */
+
+#include <nan.h>
+#include <windows.h>
+
+static NAN_METHOD(ApiConsoleProcessList) {
+  if (info.Length() != 1 ||
+      !info[0]->IsNumber()) {
+    Nan::ThrowError("Usage: getConsoleProcessList(shellPid)");
+    return;
+  }
+
+  const SHORT pid = info[0]->Uint32Value(Nan::GetCurrentContext()).FromJust();
+
+  if (!FreeConsole()) {
+    Nan::ThrowError("FreeConsole failed");
+  }
+  if (!AttachConsole(pid)) {
+    Nan::ThrowError("AttachConsole failed");
+  }
+  auto processList = std::vector<DWORD>(64);
+  auto processCount = GetConsoleProcessList(&processList[0], processList.size());
+  if (processList.size() < processCount) {
+      processList.resize(processCount);
+      processCount = GetConsoleProcessList(&processList[0], processList.size());
+  }
+  FreeConsole();
+
+  v8::Local<v8::Array> result = Nan::New<v8::Array>();
+  for (DWORD i = 0; i < processCount; i++) {
+    Nan::Set(result, i, Nan::New<v8::Number>(processList[i]));
+  }
+  info.GetReturnValue().Set(result);
+}
+
+extern "C" void init(v8::Local<v8::Object> target) {
+  Nan::HandleScope scope;
+  Nan::SetMethod(target, "getConsoleProcessList", ApiConsoleProcessList);
+};
+
+NODE_MODULE(pty, init);

addons/godot_xterm/native/src/node_pty/win/path_util.cc

@@ -0,0 +1,73 @@
+/**
+ * Copyright (c) 2013-2015, Christopher Jeffrey, Peter Sunde (MIT License)
+ * Copyright (c) 2016, Daniel Imms (MIT License).
+ * Copyright (c) 2018, Microsoft Corporation (MIT License).
+ */
+
+#include <nan.h>
+#include <Shlwapi.h> // PathCombine
+
+#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);
+  return output;
+}
+
+bool file_exists(std::wstring filename) {
+  DWORD attr = ::GetFileAttributesW(filename.c_str());
+  if (attr == INVALID_FILE_ATTRIBUTES || (attr & FILE_ATTRIBUTE_DIRECTORY)) {
+    return false;
+  }
+  return true;
+}
+
+// cmd.exe -> C:\Windows\system32\cmd.exe
+std::wstring get_shell_path(std::wstring filename) {
+  std::wstring shellpath;
+
+  if (file_exists(filename)) {
+    return shellpath;
+  }
+
+  wchar_t buffer_[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());
+  }
+
+  const wchar_t *filename_ = filename.c_str();
+
+  for (int 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 (file_exists(searchPath)) {
+      shellpath = searchPath;
+      break;
+    }
+  }
+
+  return shellpath;
+}
+
+}  // namespace path_util

addons/godot_xterm/native/src/node_pty/win/path_util.h

@@ -0,0 +1,22 @@
+/**
+ * Copyright (c) 2013-2015, Christopher Jeffrey, Peter Sunde (MIT License)
+ * Copyright (c) 2016, Daniel Imms (MIT License).
+ * Copyright (c) 2018, Microsoft Corporation (MIT License).
+ */
+
+#ifndef NODE_PTY_PATH_UTIL_H_
+#define NODE_PTY_PATH_UTIL_H_
+
+#include <nan.h>
+
+#define MAX_ENV 65536
+
+namespace path_util {
+
+const wchar_t* to_wstring(const Nan::Utf8String& str);
+bool file_exists(std::wstring filename);
+std::wstring get_shell_path(std::wstring filename);
+
+}  // namespace path_util
+
+#endif  // NODE_PTY_PATH_UTIL_H_

addons/godot_xterm/native/src/node_pty/win/winpty.cc

@@ -0,0 +1,312 @@
+/**
+ * Copyright (c) 2013-2015, Christopher Jeffrey, Peter Sunde (MIT License)
+ * Copyright (c) 2016, Daniel Imms (MIT License).
+ * Copyright (c) 2018, Microsoft Corporation (MIT License).
+ *
+ * pty.cc:
+ *   This file is responsible for starting processes
+ *   with pseudo-terminal file descriptors.
+ */
+
+#include <iostream>
+#include <nan.h>
+#include <Shlwapi.h> // PathCombine, PathIsRelative
+#include <sstream>
+#include <stdlib.h>
+#include <string.h>
+#include <string>
+#include <vector>
+#include <winpty.h>
+
+#include "path_util.h"
+
+/**
+* Misc
+*/
+extern "C" void init(v8::Local<v8::Object>);
+
+#define WINPTY_DBG_VARIABLE TEXT("WINPTYDBG")
+
+/**
+* winpty
+*/
+static std::vector<winpty_t *> ptyHandles;
+static volatile LONG ptyCounter;
+
+/**
+* Helpers
+*/
+
+static winpty_t *get_pipe_handle(int handle) {
+  for (size_t i = 0; i < ptyHandles.size(); ++i) {
+    winpty_t *ptyHandle = ptyHandles[i];
+    int current = (int)winpty_agent_process(ptyHandle);
+    if (current == handle) {
+      return ptyHandle;
+    }
+  }
+  return nullptr;
+}
+
+static bool remove_pipe_handle(int handle) {
+  for (size_t i = 0; i < ptyHandles.size(); ++i) {
+    winpty_t *ptyHandle = ptyHandles[i];
+    if ((int)winpty_agent_process(ptyHandle) == handle) {
+      winpty_free(ptyHandle);
+      ptyHandles.erase(ptyHandles.begin() + i);
+      ptyHandle = nullptr;
+      return true;
+    }
+  }
+  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());
+  winpty_error_free(error_ptr);
+}
+
+static NAN_METHOD(PtyGetExitCode) {
+  Nan::HandleScope scope;
+
+  if (info.Length() != 1 ||
+      !info[0]->IsNumber()) {
+    Nan::ThrowError("Usage: pty.getExitCode(pidHandle)");
+    return;
+  }
+
+  DWORD exitCode = 0;
+  GetExitCodeProcess((HANDLE)info[0]->IntegerValue(Nan::GetCurrentContext()).FromJust(), &exitCode);
+
+  info.GetReturnValue().Set(Nan::New<v8::Number>(exitCode));
+}
+
+static NAN_METHOD(PtyGetProcessList) {
+  Nan::HandleScope scope;
+
+  if (info.Length() != 1 ||
+      !info[0]->IsNumber()) {
+    Nan::ThrowError("Usage: pty.getProcessList(pid)");
+    return;
+  }
+
+  int pid = info[0]->Int32Value(Nan::GetCurrentContext()).FromJust();
+
+  winpty_t *pc = get_pipe_handle(pid);
+  if (pc == nullptr) {
+    info.GetReturnValue().Set(Nan::New<v8::Array>(0));
+    return;
+  }
+  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]));
+  }
+  info.GetReturnValue().Set(result);
+}
+
+static NAN_METHOD(PtyStartProcess) {
+  Nan::HandleScope scope;
+
+  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;
+  }
+
+  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]));
+
+  // create environment block
+  std::wstring env;
+  const v8::Local<v8::Array> envValues = v8::Local<v8::Array>::Cast(info[2]);
+  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';
+    }
+
+    env = envBlock.str();
+  }
+
+  // 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)) {
+    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;
+  }
+
+  int cols = info[4]->Int32Value(Nan::GetCurrentContext()).FromJust();
+  int rows = info[5]->Int32Value(Nan::GetCurrentContext()).FromJust();
+  bool debug = Nan::To<bool>(info[6]).FromJust();
+
+  // Enable/disable debugging
+  SetEnvironmentVariable(WINPTY_DBG_VARIABLE, debug ? "1" : NULL); // NULL = deletes variable
+
+  // Create winpty config
+  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;
+  }
+  winpty_error_free(error_ptr);
+
+  // Set pty size on config
+  winpty_config_set_initial_size(winpty_config, cols, rows);
+
+  // Start the pty agent
+  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;
+  }
+  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);
+  if (config == nullptr) {
+    throw_winpty_error("Error creating WinPTY spawn config", error_ptr);
+    goto cleanup;
+  }
+  winpty_error_free(error_ptr);
+
+  // Spawn the new process
+  HANDLE handle = nullptr;
+  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;
+  }
+  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());
+  }
+  info.GetReturnValue().Set(marshal);
+
+  goto cleanup;
+
+cleanup:
+  delete filename;
+  delete cmdline;
+  delete cwd;
+}
+
+static NAN_METHOD(PtyResize) {
+  Nan::HandleScope scope;
+
+  if (info.Length() != 3 ||
+      !info[0]->IsNumber() ||
+      !info[1]->IsNumber() ||
+      !info[2]->IsNumber()) {
+    Nan::ThrowError("Usage: pty.resize(pid, cols, rows)");
+    return;
+  }
+
+  int handle = info[0]->Int32Value(Nan::GetCurrentContext()).FromJust();
+  int cols = info[1]->Int32Value(Nan::GetCurrentContext()).FromJust();
+  int rows = info[2]->Int32Value(Nan::GetCurrentContext()).FromJust();
+
+  winpty_t *pc = get_pipe_handle(handle);
+
+  if (pc == nullptr) {
+    Nan::ThrowError("The pty doesn't appear to exist");
+    return;
+  }
+  BOOL success = winpty_set_size(pc, cols, rows, nullptr);
+  if (!success) {
+    Nan::ThrowError("The pty could not be resized");
+    return;
+  }
+
+  return info.GetReturnValue().SetUndefined();
+}
+
+static NAN_METHOD(PtyKill) {
+  Nan::HandleScope scope;
+
+  if (info.Length() != 2 ||
+      !info[0]->IsNumber() ||
+      !info[1]->IsNumber()) {
+    Nan::ThrowError("Usage: pty.kill(pid, innerPidHandle)");
+    return;
+  }
+
+  int handle = info[0]->Int32Value(Nan::GetCurrentContext()).FromJust();
+  HANDLE innerPidHandle = (HANDLE)info[1]->Int32Value(Nan::GetCurrentContext()).FromJust();
+
+  winpty_t *pc = get_pipe_handle(handle);
+  if (pc == nullptr) {
+    Nan::ThrowError("Pty seems to have been killed already");
+    return;
+  }
+
+  assert(remove_pipe_handle(handle));
+  CloseHandle(innerPidHandle);
+
+  return info.GetReturnValue().SetUndefined();
+}
+
+/**
+* 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);
+};
+
+NODE_MODULE(pty, init);