node-pty 1.0.0 → 1.1.0-beta10

package/src/unixTerminal.test.ts

@@ -11,6 +11,7 @@ import * as tty from 'tty';
 import * as fs from 'fs';
 import { constants } from 'os';
 import { pollUntil } from './testUtils.test';
+import { pid } from 'process';
 
 const FIXTURES_PATH = path.normalize(path.join(__dirname, '..', 'fixtures', 'utf8-character.txt'));
 
@@ -262,6 +263,40 @@ if (process.platform !== 'win32') {
           term.on('exit', () => done());
           term.destroy();
         });
+        it('should return the name of the sub process', (done) => {
+          const data = `
+          var pty = require('./lib/index');
+          var ptyProcess = pty.spawn('zsh', ['-c', 'python3'], {
+            env: process.env
+          });
+          ptyProcess.on('data', function (data) {
+            if (ptyProcess.process === 'Python') {
+              console.log('title', ptyProcess.process);
+            }
+          });
+          setTimeout(() => null, 500);
+          console.log('ready', ptyProcess.pid);
+          `;
+          const p = cp.spawn('node', ['-e', data]);
+          let sub = '';
+          let pid = '';
+          p.stdout.on('data', (data) => {
+            if (!data.toString().indexOf('title')) {
+              sub = data.toString().split(' ')[1].slice(0, -1);
+              setTimeout(() => {
+                process.kill(parseInt(pid), 'SIGINT');
+                p.kill('SIGINT');
+              }, 200);
+            } else if (!data.toString().indexOf('ready')) {
+              pid = data.toString().split(' ')[1].slice(0, -1);
+            }
+          });
+          p.on('exit', () => {
+            assert.notStrictEqual(pid, '');
+            assert.strictEqual(sub, 'Python');
+            done();
+          });
+        });
         it('should close on exec', (done) => {
           const data = `
           var pty = require('./lib/index');

package/src/unixTerminal.ts

@@ -263,7 +263,8 @@ export class UnixTerminal extends Terminal {
    */
   public get process(): string {
     if (process.platform === 'darwin') {
-      return pty.process(this._pid) || this._file;
+      const title = pty.process(this._fd);
+      return (title !== 'kernel_task' ) ? title : this._file;
     }
 
     return pty.process(this._fd, this._pty) || this._file;

package/src/win/conpty.cc

@@ -8,24 +8,20 @@
  *   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
+#define _WIN32_WINNT 0x600
 
-#include <iostream>
-#include <nan.h>
+#define NODE_ADDON_API_DISABLE_DEPRECATED
+#include <napi.h>
+#include <assert.h>
 #include <Shlwapi.h> // PathCombine, PathIsRelative
 #include <sstream>
 #include <string>
+#include <thread>
 #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 \
@@ -46,10 +42,6 @@ struct pty_baton {
   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) {};
 };
@@ -67,19 +59,65 @@ static pty_baton* get_pty_baton(int id) {
   return nullptr;
 }
 
-template <typename T>
-std::vector<T> vectorFromString(const std::basic_string<T> &str) {
-    return std::vector<T>(str.begin(), str.end());
+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;
+    }
+  }
+  return false;
+}
+
+struct ExitEvent {
+  int exit_code = 0;
+};
+
+void SetupExitCallback(Napi::Env env, Napi::Function cb, pty_baton* baton) {
+  std::thread *th = new std::thread;
+  // Don't use Napi::AsyncWorker which is limited by UV_THREADPOOL_SIZE.
+  auto tsfn = Napi::ThreadSafeFunction::New(
+      env,
+      cb,                           // JavaScript function called asynchronously
+      "SetupExitCallback_resource", // Name
+      0,                            // Unlimited queue
+      1,                            // Only one thread will use this initially
+      [th](Napi::Env) {   // Finalizer used to clean threads up
+        th->join();
+        delete th;
+      });
+  *th = std::thread([tsfn = std::move(tsfn), baton] {
+    auto callback = [](Napi::Env env, Napi::Function cb, ExitEvent *exit_event) {
+      cb.Call({Napi::Number::New(env, exit_event->exit_code)});
+      delete exit_event;
+    };
+
+    ExitEvent *exit_event = new ExitEvent;
+    // Wait for process to complete.
+    WaitForSingleObject(baton->hShell, INFINITE);
+    // 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);
+
+    auto status = tsfn.BlockingCall(exit_event, callback); // In main thread
+    assert(status == napi_ok);
+
+    tsfn.Release();
+  });
 }
 
-void throwNanError(const Nan::FunctionCallbackInfo<v8::Value>* info, const char* text, const bool getLastError) {
+Napi::Error errorWithCode(const Napi::CallbackInfo& info, const char* text) {
   std::stringstream errorText;
   errorText << text;
-  if (getLastError) {
-    errorText << ", error code: " << GetLastError();
-  }
-  Nan::ThrowError(errorText.str().c_str());
-  (*info).GetReturnValue().SetUndefined();
+  errorText << ", error code: " << GetLastError();
+  return Napi::Error::New(info.Env(), errorText.str());
 }
 
 // Returns a new server named pipe.  It has not yet been connected.
@@ -158,32 +196,32 @@ HRESULT CreateNamedPipesAndPseudoConsole(COORD size,
   return HRESULT_FROM_WIN32(GetLastError());
 }
 
-static NAN_METHOD(PtyStartProcess) {
-  Nan::HandleScope scope;
+static Napi::Value PtyStartProcess(const Napi::CallbackInfo& info) {
+  Napi::Env env(info.Env());
+  Napi::HandleScope scope(env);
 
-  v8::Local<v8::Object> marshal;
+  Napi::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;
+      !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)");
   }
 
-  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();
+  const std::wstring filename(path_util::to_wstring(info[0].As<Napi::String>()));
+  const SHORT cols = static_cast<SHORT>(info[1].As<Napi::Number>().Uint32Value());
+  const SHORT rows = static_cast<SHORT>(info[2].As<Napi::Number>().Uint32Value());
+  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();
 
   // use environment 'Path' variable to determine location of
   // the relative path that we have recieved (e.g cmd.exe)
@@ -194,13 +232,11 @@ static NAN_METHOD(PtyStartProcess) {
     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;
+    std::string why;
+    why += "File not found: ";
+    why += path_util::wstring_to_string(shellpath);
+    throw Napi::Error::New(env, why);
   }
 
   HANDLE hIn, hOut;
@@ -211,61 +247,35 @@ static NAN_METHOD(PtyStartProcess) {
   SetConsoleCtrlHandler(NULL, FALSE);
 
   // Set return values
-  marshal = Nan::New<v8::Object>();
+  marshal = Napi::Object::New(env);
 
   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));
+    marshal.Set("pty", Napi::Number::New(env, ptyId));
     ptyHandles.insert(ptyHandles.end(), new pty_baton(ptyId, hIn, hOut, hpc));
   } else {
-    Nan::ThrowError("Cannot launch conpty");
-    return;
+    throw Napi::Error::New(env, "Cannot launch conpty");
   }
 
-  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());
+  std::string inNameStr = path_util::wstring_to_string(inName);
+  if (inNameStr.empty()) {
+    throw Napi::Error::New(env, "Failed to initialize conpty conin");
+  }
+  std::string outNameStr = path_util::wstring_to_string(outName);
+  if (outNameStr.empty()) {
+    throw Napi::Error::New(env, "Failed to initialize conpty conout");
   }
-  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();
+  marshal.Set("fd", Napi::Number::New(env, -1));
+  marshal.Set("conin", Napi::String::New(env, inNameStr));
+  marshal.Set("conout", Napi::String::New(env, outNameStr));
+  return marshal;
 }
 
-static NAN_METHOD(PtyConnect) {
-  Nan::HandleScope scope;
+static Napi::Value PtyConnect(const Napi::CallbackInfo& info) {
+  Napi::Env env(info.Env());
+  Napi::HandleScope scope(env);
 
   // 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
@@ -275,26 +285,24 @@ static NAN_METHOD(PtyConnect) {
   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;
+      !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)");
   }
 
-  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]);
+  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>();
 
   // Fetch pty handle from ID and start process
   pty_baton* handle = get_pty_baton(id);
   if (!handle) {
-    Nan::ThrowError("Invalid pty handle");
-    return;
+    throw Napi::Error::New(env, "Invalid pty handle");
   }
 
   // Prepare command line
@@ -306,17 +314,17 @@ static NAN_METHOD(PtyConnect) {
   hr = StringCchCopyW(mutableCwd.get(), cwd.length() + 1, cwd.c_str());
 
   // Prepare environment
-  std::wstring env;
+  std::wstring envStr;
   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';
     }
-    envBlock << L'\0';
-    env = envBlock.str();
+    envBlock += L'\0';
+    envStr = std::move(envBlock);
   }
-  auto envV = vectorFromString(env);
+  std::vector<wchar_t> envV(envStr.cbegin(), envStr.cend());
   LPWSTR envArg = envV.empty() ? nullptr : envV.data();
 
   ConnectNamedPipe(handle->hIn, nullptr);
@@ -337,7 +345,7 @@ static NAN_METHOD(PtyConnect) {
 
   fSuccess = InitializeProcThreadAttributeList(siEx.lpAttributeList, 1, 0, &size);
   if (!fSuccess) {
-    return throwNanError(&info, "InitializeProcThreadAttributeList failed", true);
+    throw errorWithCode(info, "InitializeProcThreadAttributeList failed");
   }
   fSuccess = UpdateProcThreadAttribute(siEx.lpAttributeList,
                                        0,
@@ -347,7 +355,7 @@ static NAN_METHOD(PtyConnect) {
                                        NULL,
                                        NULL);
   if (!fSuccess) {
-    return throwNanError(&info, "UpdateProcThreadAttribute failed", true);
+    throw errorWithCode(info, "UpdateProcThreadAttribute failed");
   }
 
   PROCESS_INFORMATION piClient{};
@@ -364,40 +372,34 @@ static NAN_METHOD(PtyConnect) {
       &piClient                     // lpProcessInformation
   );
   if (!fSuccess) {
-    return throwNanError(&info, "Cannot create process", true);
+    throw errorWithCode(info, "Cannot create process");
   }
 
   // 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);
+  SetupExitCallback(env, exitCallback, handle);
 
   // 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);
+  auto marshal = Napi::Object::New(env);
+  marshal.Set("pid", Napi::Number::New(env, piClient.dwProcessId));
+  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(id, cols, rows)");
-    return;
+      !info[0].IsNumber() ||
+      !info[1].IsNumber() ||
+      !info[2].IsNumber()) {
+    throw Napi::Error::New(env, "Usage: pty.resize(id, cols, rows)");
   }
 
-  int id = info[0]->Int32Value(Nan::GetCurrentContext()).FromJust();
-  SHORT cols = info[1]->Uint32Value(Nan::GetCurrentContext()).FromJust();
-  SHORT rows = info[2]->Uint32Value(Nan::GetCurrentContext()).FromJust();
+  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 pty_baton* handle = get_pty_baton(id);
 
@@ -415,48 +417,48 @@ static NAN_METHOD(PtyResize) {
     }
   }
 
-  return info.GetReturnValue().SetUndefined();
+  return env.Undefined();
 }
 
-static NAN_METHOD(PtyClear) {
-  Nan::HandleScope scope;
+static Napi::Value PtyClear(const Napi::CallbackInfo& info) {
+  Napi::Env env(info.Env());
+  Napi::HandleScope scope(env);
 
   if (info.Length() != 1 ||
-      !info[0]->IsNumber()) {
-    Nan::ThrowError("Usage: pty.clear(id)");
-    return;
+      !info[0].IsNumber()) {
+    throw Napi::Error::New(env, "Usage: pty.clear(id)");
   }
 
-  int id = info[0]->Int32Value(Nan::GetCurrentContext()).FromJust();
+  // int id = info[0].As<Napi::Number>().Int32Value();
 
-  const pty_baton* handle = get_pty_baton(id);
+  // const pty_baton* handle = get_pty_baton(id);
 
-  if (handle != nullptr) {
-    HANDLE hLibrary = LoadLibraryExW(L"kernel32.dll", 0, 0);
-    bool fLoadedDll = hLibrary != nullptr;
-    if (fLoadedDll)
-    {
-      PFNCLEARPSEUDOCONSOLE const pfnClearPseudoConsole = (PFNCLEARPSEUDOCONSOLE)GetProcAddress((HMODULE)hLibrary, "ClearPseudoConsole");
-      if (pfnClearPseudoConsole)
-      {
-        pfnClearPseudoConsole(handle->hpc);
-      }
-    }
-  }
+  // if (handle != nullptr) {
+  //   HANDLE hLibrary = LoadLibraryExW(L"kernel32.dll", 0, 0);
+  //   bool fLoadedDll = hLibrary != nullptr;
+  //   if (fLoadedDll)
+  //   {
+  //     PFNCLEARPSEUDOCONSOLE const pfnClearPseudoConsole = (PFNCLEARPSEUDOCONSOLE)GetProcAddress((HMODULE)hLibrary, "ClearPseudoConsole");
+  //     if (pfnClearPseudoConsole)
+  //     {
+  //       pfnClearPseudoConsole(handle->hpc);
+  //     }
+  //   }
+  // }
 
-  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() != 1 ||
-      !info[0]->IsNumber()) {
-    Nan::ThrowError("Usage: pty.kill(id)");
-    return;
+      !info[0].IsNumber()) {
+    throw Napi::Error::New(env, "Usage: pty.kill(id)");
   }
 
-  int id = info[0]->Int32Value(Nan::GetCurrentContext()).FromJust();
+  int id = info[0].As<Napi::Number>().Int32Value();
 
   const pty_baton* handle = get_pty_baton(id);
 
@@ -472,27 +474,24 @@ static NAN_METHOD(PtyKill) {
       }
     }
 
-    DisconnectNamedPipe(handle->hIn);
-    DisconnectNamedPipe(handle->hOut);
-    CloseHandle(handle->hIn);
-    CloseHandle(handle->hOut);
     CloseHandle(handle->hShell);
+    assert(remove_pty_baton(id));
   }
 
-  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, "connect", PtyConnect);
-  Nan::SetMethod(target, "resize", PtyResize);
-  Nan::SetMethod(target, "clear", PtyClear);
-  Nan::SetMethod(target, "kill", PtyKill);
+Napi::Object init(Napi::Env env, Napi::Object exports) {
+  exports.Set("startProcess", Napi::Function::New(env, PtyStartProcess));
+  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("kill", Napi::Function::New(env, PtyKill));
+  return exports;
 };
 
-NODE_MODULE(pty, init);
+NODE_API_MODULE(NODE_GYP_MODULE_NAME, init);

package/src/win/conpty_console_list.cc

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