node-pty 0.11.0-beta9 → 1.1.0-beta1

package/src/unix/spawn-helper.cc

@@ -0,0 +1,23 @@
+#include <errno.h>
+#include <fcntl.h>
+#include <string.h>
+#include <unistd.h>
+
+int main (int argc, char** argv) {
+  char *slave_path = ttyname(STDIN_FILENO);
+  // open implicit attaches a process to a terminal device if:
+  // - process has no controlling terminal yet
+  // - O_NOCTTY is not set
+  close(open(slave_path, O_RDWR));
+
+  char *cwd = argv[1];
+  char *file = argv[2];
+  argv = &argv[2];
+
+  if (strlen(cwd) && chdir(cwd) == -1) {
+    _exit(1);
+  }
+
+  execvp(file, argv);
+  return 1;
+}

package/src/unixTerminal.test.ts

@@ -7,6 +7,9 @@ import { UnixTerminal } from './unixTerminal';
 import * as assert from 'assert';
 import * as cp from 'child_process';
 import * as path from 'path';
+import * as tty from 'tty';
+import * as fs from 'fs';
+import { constants } from 'os';
 import { pollUntil } from './testUtils.test';
 
 const FIXTURES_PATH = path.normalize(path.join(__dirname, '..', 'fixtures', 'utf8-character.txt'));
@@ -16,7 +19,7 @@ if (process.platform !== 'win32') {
     describe('Constructor', () => {
       it('should set a valid pts name', () => {
         const term = new UnixTerminal('/bin/bash', [], {});
-        let regExp: RegExp;
+        let regExp: RegExp | undefined;
         if (process.platform === 'linux') {
           // https://linux.die.net/man/4/pts
           regExp = /^\/dev\/pts\/\d+$/;
@@ -26,8 +29,9 @@ if (process.platform !== 'win32') {
           regExp = /^\/dev\/tty[p-sP-S][a-z0-9]+$/;
         }
         if (regExp) {
-          assert.ok(regExp.test((<any>term)._pty), '"' + (<any>term)._pty + '" should match ' + regExp.toString());
+          assert.ok(regExp.test(term.ptsName), '"' + term.ptsName + '" should match ' + regExp.toString());
         }
+        assert.ok(tty.isatty(term.fd));
       });
     });
 
@@ -35,8 +39,8 @@ if (process.platform !== 'win32') {
       it('should default to utf8', (done) => {
         const term = new UnixTerminal('/bin/bash', [ '-c', `cat "${FIXTURES_PATH}"` ]);
         term.on('data', (data) => {
-          assert.equal(typeof data, 'string');
-          assert.equal(data, '\u00E6');
+          assert.strictEqual(typeof data, 'string');
+          assert.strictEqual(data, '\u00E6');
           done();
         });
       });
@@ -45,25 +49,25 @@ if (process.platform !== 'win32') {
           encoding: null
         });
         term.on('data', (data) => {
-          assert.equal(typeof data, 'object');
+          assert.strictEqual(typeof data, 'object');
           assert.ok(data instanceof Buffer);
-          assert.equal(0xC3, data[0]);
-          assert.equal(0xA6, data[1]);
+          assert.strictEqual(0xC3, data[0]);
+          assert.strictEqual(0xA6, data[1]);
           done();
         });
       });
       it('should support other encodings', (done) => {
         const text = 'test æ!';
-        const term = new UnixTerminal(null, ['-c', 'echo "' + text + '"'], {
+        const term = new UnixTerminal(undefined, ['-c', 'echo "' + text + '"'], {
           encoding: 'base64'
         });
         let buffer = '';
-        term.on('data', (data) => {
-          assert.equal(typeof data, 'string');
+        term.onData((data) => {
+          assert.strictEqual(typeof data, 'string');
           buffer += data;
         });
-        term.on('exit', () => {
-          assert.equal(Buffer.alloc(8, buffer, 'base64').toString().replace('\r', '').replace('\n', ''), text);
+        term.onExit(() => {
+          assert.strictEqual(Buffer.alloc(8, buffer, 'base64').toString().replace('\r', '').replace('\n', ''), text);
           done();
         });
       });
@@ -74,8 +78,8 @@ if (process.platform !== 'win32') {
 
       afterEach(() => {
         if (term) {
-          term.slave.destroy();
-          term.master.destroy();
+          term.slave!.destroy();
+          term.master!.destroy();
         }
       });
 
@@ -83,12 +87,12 @@ if (process.platform !== 'win32') {
         term = UnixTerminal.open({});
 
         let slavebuf = '';
-        term.slave.on('data', (data) => {
+        term.slave!.on('data', (data) => {
           slavebuf += data;
         });
 
         let masterbuf = '';
-        term.master.on('data', (data) => {
+        term.master!.on('data', (data) => {
           masterbuf += data;
         });
 
@@ -100,8 +104,19 @@ if (process.platform !== 'win32') {
           return false;
         }, 200, 10);
 
-        term.slave.write('slave\n');
-        term.master.write('master\n');
+        term.slave!.write('slave\n');
+        term.master!.write('master\n');
+      });
+    });
+    describe('close', () => {
+      const term = new UnixTerminal('node');
+      it('should exit when terminal is destroyed programmatically', (done) => {
+        term.on('exit', (code, signal) => {
+          assert.strictEqual(code, 0);
+          assert.strictEqual(signal, constants.signals.SIGHUP);
+          done();
+        });
+        term.destroy();
       });
     });
     describe('signals in parent and child', () => {
@@ -140,8 +155,8 @@ if (process.platform !== 'win32') {
         });
         p.on('close', () => {
           // handlers in parent and child should have been triggered
-          assert.equal(buffer.indexOf('SIGINT in child') !== -1, true);
-          assert.equal(buffer.indexOf('SIGINT in parent') !== -1, true);
+          assert.strictEqual(buffer.indexOf('SIGINT in child') !== -1, true);
+          assert.strictEqual(buffer.indexOf('SIGINT in parent') !== -1, true);
           done();
         });
       });
@@ -181,8 +196,8 @@ if (process.platform !== 'win32') {
         });
         p.on('close', () => {
           // handlers in parent and child should have been triggered
-          assert.equal(buffer.indexOf('should not be printed') !== -1, false);
-          assert.equal(buffer.indexOf('SIGINT in parent') !== -1, true);
+          assert.strictEqual(buffer.indexOf('should not be printed') !== -1, false);
+          assert.strictEqual(buffer.indexOf('SIGINT in parent') !== -1, true);
           done();
         });
       });
@@ -201,7 +216,7 @@ if (process.platform !== 'win32') {
         });
         term.on('exit', () => {
           // no timeout in buffer
-          assert.equal(buffer, '');
+          assert.strictEqual(buffer, '');
           done();
         });
       });
@@ -233,11 +248,88 @@ if (process.platform !== 'win32') {
         });
         term.on('exit', () => {
           // should have called both handlers and only once
-          assert.equal(pHandlerCalled, 1);
-          assert.equal(buffer, 'SIGUSR1 in child\r\n');
+          assert.strictEqual(pHandlerCalled, 1);
+          assert.strictEqual(buffer, 'SIGUSR1 in child\r\n');
           done();
         });
       });
     });
+    describe('spawn', () => {
+      if (process.platform === 'darwin') {
+        it('should return the name of the process', (done) => {
+          const term = new UnixTerminal('/bin/echo');
+          assert.strictEqual(term.process, '/bin/echo');
+          term.on('exit', () => done());
+          term.destroy();
+        });
+        it('should close on exec', (done) => {
+          const data = `
+          var pty = require('./lib/index');
+          var ptyProcess = pty.spawn('node', ['-e', 'setTimeout(() => console.log("hello from terminal"), 300);']);
+          ptyProcess.on('data', function (data) {
+            console.log(data);
+          });
+          setTimeout(() => null, 500);
+          console.log('ready', ptyProcess.pid);
+          `;
+          const buffer: string[] = [];
+          const readFd = fs.openSync(FIXTURES_PATH, 'r');
+          const p = cp.spawn('node', ['-e', data], {
+            stdio: ['ignore', 'pipe', 'pipe', readFd]
+          });
+          let sub = '';
+          p.stdout!.on('data', (data) => {
+            if (!data.toString().indexOf('ready')) {
+              sub = data.toString().split(' ')[1].slice(0, -1);
+              try {
+                fs.statSync(`/proc/${sub}/fd/${readFd}`);
+                done('not reachable');
+              } catch (error) {
+                assert.notStrictEqual(error.message.indexOf('ENOENT'), -1);
+              }
+              setTimeout(() => {
+                process.kill(parseInt(sub), 'SIGINT');  // SIGINT to child
+                p.kill('SIGINT');                       // SIGINT to parent
+              }, 200);
+            } else {
+              buffer.push(data.toString().replace(/^\s+|\s+$/g, ''));
+            }
+          });
+          p.on('close', () => {
+            done();
+          });
+        });
+      }
+      it('should handle exec() errors', (done) => {
+        const term = new UnixTerminal('/bin/bogus.exe', []);
+        term.on('exit', (code, signal) => {
+          assert.strictEqual(code, 1);
+          done();
+        });
+      });
+      it('should handle chdir() errors', (done) => {
+        const term = new UnixTerminal('/bin/echo', [], { cwd: '/nowhere' });
+        term.on('exit', (code, signal) => {
+          assert.strictEqual(code, 1);
+          done();
+        });
+      });
+      it('should not leak child process', (done) => {
+        const count = cp.execSync('ps -ax | grep node | wc -l');
+        const term = new UnixTerminal('node', [ '-e', `
+          console.log('ready');
+          setTimeout(()=>console.log('timeout'), 200);`
+        ]);
+        term.on('data', async (data) => {
+          if (data === 'ready\r\n') {
+            process.kill(term.pid, 'SIGINT');
+            await setTimeout(() => null, 1000);
+            const newCount = cp.execSync('ps -ax | grep node | wc -l');
+            assert.strictEqual(count.toString(), newCount.toString());
+            done();
+          }
+        });
+      });
+    });
   });
 }

package/src/unixTerminal.ts

@@ -4,17 +4,21 @@
  * Copyright (c) 2018, Microsoft Corporation (MIT License).
  */
 import * as net from 'net';
+import * as path from 'path';
 import { Terminal, DEFAULT_COLS, DEFAULT_ROWS } from './terminal';
 import { IProcessEnv, IPtyForkOptions, IPtyOpenOptions } from './interfaces';
 import { ArgvOrCommandLine } from './types';
 import { assign } from './utils';
 
 let pty: IUnixNative;
+let helperPath: string;
 try {
   pty = require('../build/Release/pty.node');
+  helperPath = '../build/Release/spawn-helper';
 } catch (outerError) {
   try {
     pty = require('../build/Debug/pty.node');
+    helperPath = '../build/Debug/spawn-helper';
   } catch (innerError) {
     console.error('innerError', innerError);
     // Re-throw the exception from the Release require if the Debug require fails as well
@@ -22,6 +26,10 @@ try {
   }
 }
 
+helperPath = path.resolve(__dirname, helperPath);
+helperPath = helperPath.replace('app.asar', 'app.asar.unpacked');
+helperPath = helperPath.replace('node_modules.asar', 'node_modules.asar.unpacked');
+
 const DEFAULT_FILE = 'sh';
 const DEFAULT_NAME = 'xterm';
 const DESTROY_SOCKET_TIMEOUT_MS = 200;
@@ -36,13 +44,13 @@ export class UnixTerminal extends Terminal {
   protected _readable: boolean;
   protected _writable: boolean;
 
-  private _boundClose: boolean;
-  private _emittedClose: boolean;
-  private _master: net.Socket;
-  private _slave: net.Socket;
+  private _boundClose: boolean = false;
+  private _emittedClose: boolean = false;
+  private _master: net.Socket | undefined;
+  private _slave: net.Socket | undefined;
 
-  public get master(): net.Socket { return this._master; }
-  public get slave(): net.Socket { return this._slave; }
+  public get master(): net.Socket | undefined { return this._master; }
+  public get slave(): net.Socket | undefined { return this._slave; }
 
   constructor(file?: string, args?: ArgvOrCommandLine, opt?: IPtyForkOptions) {
     super(opt);
@@ -59,8 +67,8 @@ export class UnixTerminal extends Terminal {
 
     this._cols = opt.cols || DEFAULT_COLS;
     this._rows = opt.rows || DEFAULT_ROWS;
-    const uid = opt.uid || -1;
-    const gid = opt.gid || -1;
+    const uid = opt.uid ?? -1;
+    const gid = opt.gid ?? -1;
     const env: IProcessEnv = assign({}, opt.env);
 
     if (opt.env === process.env) {
@@ -86,7 +94,7 @@ export class UnixTerminal extends Terminal {
         // From macOS High Sierra 10.13.2 sometimes the socket never gets
         // closed. A timeout is applied here to avoid the terminal never being
         // destroyed when this occurs.
-        let timeout = setTimeout(() => {
+        let timeout: NodeJS.Timeout | null = setTimeout(() => {
           timeout = null;
           // Destroying the socket now will cause the close event to fire
           this._socket.destroy();
@@ -103,7 +111,7 @@ export class UnixTerminal extends Terminal {
     };
 
     // fork
-    const term = pty.fork(file, args, parsedEnv, cwd, this._cols, this._rows, uid, gid, (encoding === 'utf8'), onexit);
+    const term = pty.fork(file, args, parsedEnv, cwd, this._cols, this._rows, uid, gid, (encoding === 'utf8'), helperPath, onexit);
 
     this._socket = new PipeSocket(term.fd);
     if (encoding !== null) {
@@ -169,6 +177,10 @@ export class UnixTerminal extends Terminal {
     this._socket.write(data);
   }
 
+  /* Accessors */
+  get fd(): number { return this._fd; }
+  get ptsName(): string { return this._pty; }
+
   /**
    * openpty
    */
@@ -204,7 +216,7 @@ export class UnixTerminal extends Terminal {
     self._slave.resume();
 
     self._socket = self._master;
-    self._pid = null;
+    self._pid = -1;
     self._fd = term.master;
     self._pty = term.pty;
 
@@ -250,6 +262,10 @@ export class UnixTerminal extends Terminal {
    * Gets the name of the process.
    */
   public get process(): string {
+    if (process.platform === 'darwin') {
+      return pty.process(this._pid) || this._file;
+    }
+
     return pty.process(this._fd, this._pty) || this._file;
   }
 
@@ -266,6 +282,10 @@ export class UnixTerminal extends Terminal {
     this._rows = rows;
   }
 
+  public clear(): void {
+
+  }
+
   private _sanitizeEnv(env: IProcessEnv): void {
     // Make sure we didn't start our server from inside tmux.
     delete env['TMUX'];

package/src/win/conpty.cc

@@ -34,6 +34,7 @@ extern "C" void init(v8::Local<v8::Object>);
 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 HRESULT (__stdcall *PFNCLEARPSEUDOCONSOLE)(HPCON hpc);
 typedef void (__stdcall *PFNCLOSEPSEUDOCONSOLE)(HPCON hpc);
 
 #endif
@@ -178,8 +179,8 @@ static NAN_METHOD(PtyStartProcess) {
   }
 
   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 SHORT cols = static_cast<SHORT>(info[1]->Uint32Value(Nan::GetCurrentContext()).FromJust());
+  const SHORT rows = static_cast<SHORT>(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();
@@ -193,12 +194,10 @@ 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());
+    std::wstringstream why;
+    why << "File not found: " << shellpath;
+    Nan::ThrowError(path_util::from_wstring(why.str().c_str()));
     return;
   }
 
@@ -222,14 +221,20 @@ static NAN_METHOD(PtyStartProcess) {
     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());
+  std::string inNameStr(path_util::from_wstring(inName.c_str()));
+  if (inNameStr.empty()) {
+    Nan::ThrowError("Failed to initialize conpty conin");
+    return;
+  }
+  std::string outNameStr(path_util::from_wstring(outName.c_str()));
+  if (outNameStr.empty()) {
+    Nan::ThrowError("Failed to initialize conpty conout");
+    return;
   }
+
+  Nan::Set(marshal, Nan::New<v8::String>("fd").ToLocalChecked(), Nan::New<v8::Number>(-1));
+  Nan::Set(marshal, Nan::New<v8::String>("conin").ToLocalChecked(), Nan::New<v8::String>(inNameStr).ToLocalChecked());
+  Nan::Set(marshal, Nan::New<v8::String>("conout").ToLocalChecked(), Nan::New<v8::String>(outNameStr).ToLocalChecked());
   info.GetReturnValue().Set(marshal);
 }
 
@@ -289,6 +294,13 @@ static NAN_METHOD(PtyConnect) {
   const v8::Local<v8::Array> envValues = info[3].As<v8::Array>();
   const v8::Local<v8::Function> exitCallback = v8::Local<v8::Function>::Cast(info[4]);
 
+  // Fetch pty handle from ID and start process
+  pty_baton* handle = get_pty_baton(id);
+  if (!handle) {
+    Nan::ThrowError("Invalid pty handle");
+    return;
+  }
+
   // 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());
@@ -311,11 +323,8 @@ static NAN_METHOD(PtyConnect) {
   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);
+  ConnectNamedPipe(handle->hIn, nullptr);
+  ConnectNamedPipe(handle->hOut, nullptr);
 
   // Attach the pseudoconsole to the client application we're creating
   STARTUPINFOEXW siEx{0};
@@ -391,20 +400,51 @@ static NAN_METHOD(PtyResize) {
   }
 
   int id = info[0]->Int32Value(Nan::GetCurrentContext()).FromJust();
-  SHORT cols = info[1]->Uint32Value(Nan::GetCurrentContext()).FromJust();
-  SHORT rows = info[2]->Uint32Value(Nan::GetCurrentContext()).FromJust();
+  SHORT cols = static_cast<SHORT>(info[1]->Uint32Value(Nan::GetCurrentContext()).FromJust());
+  SHORT rows = static_cast<SHORT>(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)
+  if (handle != nullptr) {
+    HANDLE hLibrary = LoadLibraryExW(L"kernel32.dll", 0, 0);
+    bool fLoadedDll = hLibrary != nullptr;
+    if (fLoadedDll)
     {
-      COORD size = {cols, rows};
-      pfnResizePseudoConsole(handle->hpc, size);
+      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(PtyClear) {
+  Nan::HandleScope scope;
+
+  if (info.Length() != 1 ||
+      !info[0]->IsNumber()) {
+    Nan::ThrowError("Usage: pty.clear(id)");
+    return;
+  }
+
+  int id = info[0]->Int32Value(Nan::GetCurrentContext()).FromJust();
+
+  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);
+      }
     }
   }
 
@@ -424,18 +464,24 @@ static NAN_METHOD(PtyKill) {
 
   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)
+  if (handle != nullptr) {
+    HANDLE hLibrary = LoadLibraryExW(L"kernel32.dll", 0, 0);
+    bool fLoadedDll = hLibrary != nullptr;
+    if (fLoadedDll)
     {
-      pfnClosePseudoConsole(handle->hpc);
+      PFNCLOSEPSEUDOCONSOLE const pfnClosePseudoConsole = (PFNCLOSEPSEUDOCONSOLE)GetProcAddress((HMODULE)hLibrary, "ClosePseudoConsole");
+      if (pfnClosePseudoConsole)
+      {
+        pfnClosePseudoConsole(handle->hpc);
+      }
     }
-  }
 
-  CloseHandle(handle->hShell);
+    DisconnectNamedPipe(handle->hIn);
+    DisconnectNamedPipe(handle->hOut);
+    CloseHandle(handle->hIn);
+    CloseHandle(handle->hOut);
+    CloseHandle(handle->hShell);
+  }
 
   return info.GetReturnValue().SetUndefined();
 }
@@ -449,6 +495,7 @@ extern "C" void init(v8::Local<v8::Object> target) {
   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);
 };
 

package/src/win/conpty_console_list.cc

@@ -12,7 +12,7 @@ static NAN_METHOD(ApiConsoleProcessList) {
     return;
   }
 
-  const SHORT pid = info[0]->Uint32Value(Nan::GetCurrentContext()).FromJust();
+  const DWORD pid = info[0]->Uint32Value(Nan::GetCurrentContext()).FromJust();
 
   if (!FreeConsole()) {
     Nan::ThrowError("FreeConsole failed");
@@ -21,10 +21,10 @@ static NAN_METHOD(ApiConsoleProcessList) {
     Nan::ThrowError("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();
 

package/src/win/path_util.cc

@@ -13,9 +13,28 @@ 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);
+  int sizeOfStr = MultiByteToWideChar(CP_UTF8, 0, bytes, -1, NULL, 0);
+  if (sizeOfStr <= 0) {
+    return L"";
+  }
   wchar_t *output = new wchar_t[sizeOfStr];
-  MultiByteToWideChar(CP_UTF8, 0, bytes, -1, output, sizeOfStr);
+  int status = MultiByteToWideChar(CP_UTF8, 0, bytes, -1, output, sizeOfStr);
+  if (status == 0) {
+    return L"";
+  }
+  return output;
+}
+
+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;
 }
 
@@ -52,7 +71,7 @@ std::wstring get_shell_path(std::wstring filename) {
 
   const wchar_t *filename_ = filename.c_str();
 
-  for (int i = 0; i < paths.size(); ++i) {
+  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_);

package/src/win/path_util.h

@@ -14,6 +14,7 @@
 namespace path_util {
 
 const wchar_t* to_wstring(const Nan::Utf8String& str);
+const char* from_wstring(const wchar_t* wstr);
 bool file_exists(std::wstring filename);
 std::wstring get_shell_path(std::wstring filename);