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

package/src/windowsPtyAgent.ts

@@ -7,10 +7,11 @@
 import * as fs from 'fs';
 import * as os from 'os';
 import * as path from 'path';
+import { fork } from 'child_process';
 import { Socket } from 'net';
 import { ArgvOrCommandLine } from './types';
-import { fork } from 'child_process';
 import { ConoutConnection } from './windowsConoutConnection';
+import { loadNativeModule } from './utils';
 
 let conptyNative: IConptyNative;
 let winptyNative: IWinptyNative;
@@ -54,6 +55,7 @@ export class WindowsPtyAgent {
     rows: number,
     debug: boolean,
     private _useConpty: boolean | undefined,
+    private _useConptyDll: boolean = false,
     conptyInheritCursor: boolean = false
   ) {
     if (this._useConpty === undefined || this._useConpty === true) {
@@ -61,31 +63,11 @@ export class WindowsPtyAgent {
     }
     if (this._useConpty) {
       if (!conptyNative) {
-        try {
-          conptyNative = require('../build/Release/conpty.node');
-        } catch (outerError) {
-          try {
-            conptyNative = require('../build/Debug/conpty.node');
-          } catch (innerError) {
-            console.error('innerError', innerError);
-            // Re-throw the exception from the Release require if the Debug require fails as well
-            throw outerError;
-          }
-        }
+        conptyNative = loadNativeModule('conpty').module;
       }
     } else {
       if (!winptyNative) {
-        try {
-          winptyNative = require('../build/Release/pty.node');
-        } catch (outerError) {
-          try {
-            winptyNative = require('../build/Debug/pty.node');
-          } catch (innerError) {
-            console.error('innerError', innerError);
-            // Re-throw the exception from the Release require if the Debug require fails as well
-            throw outerError;
-          }
-        }
+        winptyNative = loadNativeModule('pty').module;
       }
     }
     this._ptyNative = this._useConpty ? conptyNative : winptyNative;
@@ -99,7 +81,7 @@ export class WindowsPtyAgent {
     // Open pty session.
     let term: IConptyProcess | IWinptyProcess;
     if (this._useConpty) {
-      term = (this._ptyNative as IConptyNative).startProcess(file, cols, rows, debug, this._generatePipeName(), conptyInheritCursor);
+      term = (this._ptyNative as IConptyNative).startProcess(file, cols, rows, debug, this._generatePipeName(), conptyInheritCursor, this._useConptyDll);
     } else {
       term = (this._ptyNative as IWinptyNative).startProcess(file, commandLine, env, cwd, cols, rows, debug);
       this._pid = (term as IWinptyProcess).pid;
@@ -117,7 +99,7 @@ export class WindowsPtyAgent {
     this._outSocket = new Socket();
     this._outSocket.setEncoding('utf8');
     // The conout socket must be ready out on another thread to avoid deadlocks
-    this._conoutSocketWorker = new ConoutConnection(term.conout);
+    this._conoutSocketWorker = new ConoutConnection(term.conout, this._useConptyDll);
     this._conoutSocketWorker.onReady(() => {
       this._conoutSocketWorker.connectSocket(this._outSocket);
     });
@@ -134,7 +116,7 @@ export class WindowsPtyAgent {
     this._inSocket.setEncoding('utf8');
 
     if (this._useConpty) {
-      const connect = (this._ptyNative as IConptyNative).connect(this._pty, commandLine, cwd, env, c => this._$onProcessExit(c));
+      const connect = (this._ptyNative as IConptyNative).connect(this._pty, commandLine, cwd, env, this._useConptyDll, c => this._$onProcessExit(c));
       this._innerPid = connect.pid;
     }
   }
@@ -144,33 +126,43 @@ export class WindowsPtyAgent {
       if (this._exitCode !== undefined) {
         throw new Error('Cannot resize a pty that has already exited');
       }
-      this._ptyNative.resize(this._pty, cols, rows);
+      (this._ptyNative as IConptyNative).resize(this._pty, cols, rows, this._useConptyDll);
       return;
     }
-    this._ptyNative.resize(this._pid, cols, rows);
+    (this._ptyNative as IWinptyNative).resize(this._pid, cols, rows);
   }
 
   public clear(): void {
     if (this._useConpty) {
-      (this._ptyNative as IConptyNative).clear(this._pty);
+      (this._ptyNative as IConptyNative).clear(this._pty, this._useConptyDll);
     }
   }
 
   public kill(): void {
-    this._inSocket.readable = false;
-    this._outSocket.readable = false;
     // Tell the agent to kill the pty, this releases handles to the process
     if (this._useConpty) {
-      this._getConsoleProcessList().then(consoleProcessList => {
-        consoleProcessList.forEach((pid: number) => {
-          try {
-            process.kill(pid);
-          } catch (e) {
-            // Ignore if process cannot be found (kill ESRCH error)
-          }
+      if (!this._useConptyDll) {
+        this._inSocket.readable = false;
+        this._outSocket.readable = false;
+        this._getConsoleProcessList().then(consoleProcessList => {
+          consoleProcessList.forEach((pid: number) => {
+            try {
+              process.kill(pid);
+            } catch (e) {
+              // Ignore if process cannot be found (kill ESRCH error)
+            }
+          });
         });
-        (this._ptyNative as IConptyNative).kill(this._pty);
-      });
+        (this._ptyNative as IConptyNative).kill(this._pty, this._useConptyDll);
+        this._conoutSocketWorker.dispose();
+      } else {
+        // Close the input write handle to signal the end of session.
+        this._inSocket.destroy();
+        (this._ptyNative as IConptyNative).kill(this._pty, this._useConptyDll);
+        this._outSocket.on('data', () => {
+          this._conoutSocketWorker.dispose();
+        });
+      }
     } else {
       // 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
@@ -188,7 +180,6 @@ export class WindowsPtyAgent {
         }
       });
     }
-    this._conoutSocketWorker.dispose();
   }
 
   private _getConsoleProcessList(): Promise<number[]> {
@@ -232,11 +223,16 @@ export class WindowsPtyAgent {
    */
   private _$onProcessExit(exitCode: number): void {
     this._exitCode = exitCode;
-    this._flushDataAndCleanUp();
-    this._outSocket.on('data', () => this._flushDataAndCleanUp());
+    if (!this._useConptyDll) {
+      this._flushDataAndCleanUp();
+      this._outSocket.on('data', () => this._flushDataAndCleanUp());
+    }
   }
 
   private _flushDataAndCleanUp(): void {
+    if (this._useConptyDll) {
+      return;
+    }
     if (this._closeTimeout) {
       clearTimeout(this._closeTimeout);
     }
@@ -244,6 +240,9 @@ export class WindowsPtyAgent {
   }
 
   private _cleanUpProcess(): void {
+    if (this._useConptyDll) {
+      return;
+    }
     this._inSocket.readable = false;
     this._outSocket.readable = false;
     this._outSocket.destroy();

package/src/windowsTerminal.test.ts

@@ -26,13 +26,16 @@ function pollForProcessState(desiredState: IProcessState, intervalMs: number = 1
       psList({ all: true }).then(ps => {
         let success = true;
         const pids = Object.keys(desiredState).map(k => parseInt(k, 10));
+        console.log('expected pids', JSON.stringify(pids));
         pids.forEach(pid => {
           if (desiredState[pid]) {
             if (!ps.some(p => p.pid === pid)) {
+              console.log(`pid ${pid} does not exist`);
               success = false;
             }
           } else {
             if (ps.some(p => p.pid === pid)) {
+              console.log(`pid ${pid} still exists`);
               success = false;
             }
           }
@@ -71,6 +74,7 @@ function pollForProcessTreeSize(pid: number, size: number, intervalMs: number =
           }).forEach(p => openList.push(p));
           list.push(current);
         }
+        console.log('list', JSON.stringify(list));
         const success = list.length === size;
         if (success) {
           clearInterval(interval);
@@ -88,53 +92,57 @@ function pollForProcessTreeSize(pid: number, size: number, intervalMs: number =
 }
 
 if (process.platform === 'win32') {
-  [true, false].forEach((useConpty) => {
-    describe(`WindowsTerminal (useConpty = ${useConpty})`, () => {
+  [[false, false], [true, false], [true, true]].forEach(([useConpty, useConptyDll]) => {
+    describe(`WindowsTerminal (useConpty = ${useConpty}, useConptyDll = ${useConptyDll})`, () => {
       describe('kill', () => {
-        it('should not crash parent process', (done) => {
-          const term = new WindowsTerminal('cmd.exe', [], { useConpty });
+        it('should not crash parent process', function (done) {
+          this.timeout(20000);
+          const term = new WindowsTerminal('cmd.exe', [], { useConpty, useConptyDll });
+          term.on('exit', () => done());
           term.kill();
-          // Add done call to deferred function queue to ensure the kill call has completed
-          (<any>term)._defer(done);
         });
         it('should kill the process tree', function (done: Mocha.Done): void {
-          this.timeout(5000);
-          const term = new WindowsTerminal('cmd.exe', [], { useConpty });
+          this.timeout(20000);
+          const term = new WindowsTerminal('cmd.exe', [], { useConpty, useConptyDll });
           // Start sub-processes
           term.write('powershell.exe\r');
-          term.write('notepad.exe\r');
           term.write('node.exe\r');
-          pollForProcessTreeSize(term.pid, 4, 500, 5000).then(list => {
+          console.log('start poll for tree size');
+          pollForProcessTreeSize(term.pid, 3, 500, 5000).then(list => {
             assert.strictEqual(list[0].name.toLowerCase(), 'cmd.exe');
             assert.strictEqual(list[1].name.toLowerCase(), 'powershell.exe');
-            assert.strictEqual(list[2].name.toLowerCase(), 'notepad.exe');
-            assert.strictEqual(list[3].name.toLowerCase(), 'node.exe');
+            assert.strictEqual(list[2].name.toLowerCase(), 'node.exe');
             term.kill();
             const desiredState: IProcessState = {};
             desiredState[list[0].pid] = false;
             desiredState[list[1].pid] = false;
-            desiredState[list[2].pid] = true;
-            desiredState[list[3].pid] = false;
-            pollForProcessState(desiredState).then(() => {
-              // Kill notepad before done
-              process.kill(list[2].pid);
-              done();
+            desiredState[list[2].pid] = false;
+            term.on('exit', () => {
+              pollForProcessState(desiredState, 1000, 5000).then(() => {
+                done();
+              });
             });
           });
         });
       });
 
       describe('resize', () => {
-        it('should throw a non-native exception when resizing an invalid value', () => {
-          const term = new WindowsTerminal('cmd.exe', [], { useConpty });
+        it('should throw a non-native exception when resizing an invalid value', function(done) {
+          this.timeout(20000);
+          const term = new WindowsTerminal('cmd.exe', [], { useConpty, useConptyDll });
           assert.throws(() => term.resize(-1, -1));
           assert.throws(() => term.resize(0, 0));
           assert.doesNotThrow(() => term.resize(1, 1));
+          term.on('exit', () => {
+            done();
+          });
+          term.kill();
         });
-        it('should throw a non-native exception when resizing a killed terminal', (done) => {
-          const term = new WindowsTerminal('cmd.exe', [], { useConpty });
+        it('should throw a non-native exception when resizing a killed terminal', function(done) {
+          this.timeout(20000);
+          const term = new WindowsTerminal('cmd.exe', [], { useConpty, useConptyDll });
           (<any>term)._defer(() => {
-            term.on('exit', () => {
+            term.once('exit', () => {
               assert.throws(() => term.resize(1, 1));
               done();
             });
@@ -144,7 +152,8 @@ if (process.platform === 'win32') {
       });
 
       describe('Args as CommandLine', () => {
-        it('should not fail running a file containing a space in the path', (done) => {
+        it('should not fail running a file containing a space in the path', function (done) {
+          this.timeout(10000);
           const spaceFolder = path.resolve(__dirname, '..', 'fixtures', 'space folder');
           if (!fs.existsSync(spaceFolder)) {
             fs.mkdirSync(spaceFolder);
@@ -158,7 +167,7 @@ if (process.platform === 'win32') {
             // Skip test if git bash isn't installed
             return;
           }
-          const term = new WindowsTerminal(cmdCopiedPath, '/c echo "hello world"', { useConpty });
+          const term = new WindowsTerminal(cmdCopiedPath, '/c echo "hello world"', { useConpty, useConptyDll });
           let result = '';
           term.on('data', (data) => {
             result += data;
@@ -171,8 +180,9 @@ if (process.platform === 'win32') {
       });
 
       describe('env', () => {
-        it('should set environment variables of the shell', (done) => {
-          const term = new WindowsTerminal('cmd.exe', '/C echo %FOO%', { env: { FOO: 'BAR' }});
+        it('should set environment variables of the shell', function (done) {
+          this.timeout(10000);
+          const term = new WindowsTerminal('cmd.exe', '/C echo %FOO%', { useConpty, useConptyDll, env: { FOO: 'BAR' }});
           let result = '';
           term.on('data', (data) => {
             result += data;
@@ -185,16 +195,18 @@ if (process.platform === 'win32') {
       });
 
       describe('On close', () => {
-        it('should return process zero exit codes', (done) => {
-          const term = new WindowsTerminal('cmd.exe', '/C exit', { useConpty });
+        it('should return process zero exit codes', function (done) {
+          this.timeout(10000);
+          const term = new WindowsTerminal('cmd.exe', '/C exit', { useConpty, useConptyDll });
           term.on('exit', (code) => {
             assert.strictEqual(code, 0);
             done();
           });
         });
 
-        it('should return process non-zero exit codes', (done) => {
-          const term = new WindowsTerminal('cmd.exe', '/C exit 2', { useConpty });
+        it('should return process non-zero exit codes', function (done) {
+          this.timeout(10000);
+          const term = new WindowsTerminal('cmd.exe', '/C exit 2', { useConpty, useConptyDll });
           term.on('exit', (code) => {
             assert.strictEqual(code, 2);
             done();
@@ -203,8 +215,9 @@ if (process.platform === 'win32') {
       });
 
       describe('Write', () => {
-        it('should accept input', (done) => {
-          const term = new WindowsTerminal('cmd.exe', '', { useConpty });
+        it('should accept input', function (done) {
+          this.timeout(10000);
+          const term = new WindowsTerminal('cmd.exe', '', { useConpty, useConptyDll });
           term.write('exit\r');
           term.on('exit', () => {
             done();

package/src/windowsTerminal.ts

@@ -16,7 +16,7 @@ const DEFAULT_NAME = 'Windows Shell';
 
 export class WindowsTerminal extends Terminal {
   private _isReady: boolean;
-  private _deferreds: any[];
+  private _deferreds: { run: () => void }[];
   private _agent: WindowsPtyAgent;
 
   constructor(file?: string, args?: ArgvOrCommandLine, opt?: IWindowsPtyForkOptions) {
@@ -48,7 +48,7 @@ export class WindowsTerminal extends Terminal {
     this._deferreds = [];
 
     // Create new termal.
-    this._agent = new WindowsPtyAgent(file, args, parsedEnv, cwd, this._cols, this._rows, false, opt.useConpty, opt.conptyInheritCursor);
+    this._agent = new WindowsPtyAgent(file, args, parsedEnv, cwd, this._cols, this._rows, false, opt.useConpty, opt.useConptyDll, opt.conptyInheritCursor);
     this._socket = this._agent.outSocket;
 
     // Not available until `ready` event emitted.
@@ -60,31 +60,26 @@ export class WindowsTerminal extends Terminal {
     // emitted.
     this._socket.on('ready_datapipe', () => {
 
-      // These events needs to be forwarded.
-      ['connect', 'data', 'end', 'timeout', 'drain'].forEach(event => {
-        this._socket.on(event, () => {
-
-          // Wait until the first data event is fired then we can run deferreds.
-          if (!this._isReady && event === 'data') {
-
-            // Terminal is now ready and we can avoid having to defer method
-            // calls.
-            this._isReady = true;
-
-            // Execute all deferred methods
-            this._deferreds.forEach(fn => {
-              // NB! In order to ensure that `this` has all its references
-              // updated any variable that need to be available in `this` before
-              // the deferred is run has to be declared above this forEach
-              // statement.
-              fn.run();
-            });
-
-            // Reset
-            this._deferreds = [];
-
-          }
-        });
+      // Run deferreds and set ready state once the first data event is received.
+      this._socket.once('data', () => {
+        // Wait until the first data event is fired then we can run deferreds.
+        if (!this._isReady) {
+          // Terminal is now ready and we can avoid having to defer method
+          // calls.
+          this._isReady = true;
+
+          // Execute all deferred methods
+          this._deferreds.forEach(fn => {
+            // NB! In order to ensure that `this` has all its references
+            // updated any variable that need to be available in `this` before
+            // the deferred is run has to be declared above this forEach
+            // statement.
+            fn.run();
+          });
+
+          // Reset
+          this._deferreds = [];
+        }
       });
 
       // Shutdown if `error` event is emitted.
@@ -123,11 +118,11 @@ export class WindowsTerminal extends Terminal {
     this._forwardEvents();
   }
 
-  protected _write(data: string): void {
+  protected _write(data: string | Buffer): void {
     this._defer(this._doWrite, data);
   }
 
-  private _doWrite(data: string): void {
+  private _doWrite(data: string | Buffer): void {
     this._agent.inSocket.write(data);
   }
 

package/src/worker/conoutSocketWorker.ts

@@ -6,7 +6,8 @@ import { parentPort, workerData } from 'worker_threads';
 import { Socket, createServer } from 'net';
 import { ConoutWorkerMessage, IWorkerData, getWorkerPipeName } from '../shared/conout';
 
-const conoutPipeName = (workerData as IWorkerData).conoutPipeName;
+const { conoutPipeName } = (workerData as IWorkerData);
+
 const conoutSocket = new Socket();
 conoutSocket.setEncoding('utf8');
 conoutSocket.connect(conoutPipeName, () => {
@@ -14,7 +15,6 @@ conoutSocket.connect(conoutPipeName, () => {
     conoutSocket.pipe(workerSocket);
   });
   server.listen(getWorkerPipeName(conoutPipeName));
-
   if (!parentPort) {
     throw new Error('worker_threads parentPort is null');
   }

package/typings/node-pty.d.ts

@@ -95,6 +95,14 @@ declare module 'node-pty' {
      */
     useConpty?: boolean;
 
+    /**
+     * (EXPERIMENTAL)
+     *
+     * Whether to use the conpty.dll shipped with the node-pty package instead of the one built into
+     * Windows. Defaults to false.
+     */
+    useConptyDll?: boolean;
+
     /**
      * Whether to use PSEUDOCONSOLE_INHERIT_CURSOR in conpty.
      * @see https://docs.microsoft.com/en-us/windows/console/createpseudoconsole
@@ -165,7 +173,7 @@ declare module 'node-pty' {
      * Writes data to the pty.
      * @param data The data to write.
      */
-    write(data: string): void;
+    write(data: string | Buffer): void;
 
     /**
      * Kills the pty.