node-pty 0.10.1 → 0.11.0-beta12

package/src/windowsConoutConnection.ts

@@ -0,0 +1,79 @@
+/**
+ * Copyright (c) 2020, Microsoft Corporation (MIT License).
+ */
+
+import { Worker } from 'worker_threads';
+import { Socket } from 'net';
+import { IDisposable } from './types';
+import { IWorkerData, ConoutWorkerMessage, getWorkerPipeName } from './shared/conout';
+import { join } from 'path';
+import { IEvent, EventEmitter2 } from './eventEmitter2';
+
+/**
+ * The amount of time to wait for additional data after the conpty shell process has exited before
+ * shutting down the worker and sockets. The timer will be reset if a new data event comes in after
+ * the timer has started.
+ */
+const FLUSH_DATA_INTERVAL = 1000;
+
+/**
+ * Connects to and manages the lifecycle of the conout socket. This socket must be drained on
+ * another thread in order to avoid deadlocks where Conpty waits for the out socket to drain
+ * when `ClosePseudoConsole` is called. This happens when data is being written to the terminal when
+ * the pty is closed.
+ *
+ * See also:
+ * - https://github.com/microsoft/node-pty/issues/375
+ * - https://github.com/microsoft/vscode/issues/76548
+ * - https://github.com/microsoft/terminal/issues/1810
+ * - https://docs.microsoft.com/en-us/windows/console/closepseudoconsole
+ */
+export class ConoutConnection implements IDisposable {
+  private _worker: Worker;
+  private _drainTimeout: NodeJS.Timeout;
+  private _isDisposed: boolean = false;
+
+  private _onReady = new EventEmitter2<void>();
+  public get onReady(): IEvent<void> { return this._onReady.event; }
+
+  constructor(
+    private _conoutPipeName: string
+  ) {
+    const workerData: IWorkerData = { conoutPipeName: _conoutPipeName };
+    const scriptPath = __dirname.replace('node_modules.asar', 'node_modules.asar.unpacked');
+    this._worker = new Worker(join(scriptPath, 'worker/conoutSocketWorker.js'), { workerData });
+    this._worker.on('message', (message: ConoutWorkerMessage) => {
+      switch (message) {
+        case ConoutWorkerMessage.READY:
+          this._onReady.fire();
+          return;
+        default:
+          console.warn('Unexpected ConoutWorkerMessage', message);
+      }
+    });
+  }
+
+  dispose(): void {
+    if (this._isDisposed) {
+      return;
+    }
+    this._isDisposed = true;
+    // Drain all data from the socket before closing
+    this._drainDataAndClose();
+  }
+
+  connectSocket(socket: Socket): void {
+    socket.connect(getWorkerPipeName(this._conoutPipeName));
+  }
+
+  private _drainDataAndClose(): void {
+    if (this._drainTimeout) {
+      clearTimeout(this._drainTimeout);
+    }
+    this._drainTimeout = setTimeout(() => this._destroySocket(), FLUSH_DATA_INTERVAL);
+  }
+
+  private async _destroySocket(): Promise<void> {
+    await this._worker.terminate();
+  }
+}

package/src/windowsPtyAgent.ts

@@ -10,6 +10,7 @@ import * as path from 'path';
 import { Socket } from 'net';
 import { ArgvOrCommandLine } from './types';
 import { fork } from 'child_process';
+import { ConoutConnection } from './windowsConoutConnection';
 
 let conptyNative: IConptyNative;
 let winptyNative: IWinptyNative;
@@ -19,7 +20,7 @@ let winptyNative: IWinptyNative;
  * shutting down the socket. The timer will be reset if a new data event comes in after the timer
  * has started.
  */
-const FLUSH_DATA_INTERVAL = 20;
+const FLUSH_DATA_INTERVAL = 1000;
 
 /**
  * This agent sits between the WindowsTerminal class and provides a common interface for both conpty
@@ -33,6 +34,7 @@ export class WindowsPtyAgent {
   private _innerPidHandle: number;
   private _closeTimeout: NodeJS.Timer;
   private _exitCode: number | undefined;
+  private _conoutSocketWorker: ConoutConnection;
 
   private _fd: any;
   private _pty: number;
@@ -116,10 +118,12 @@ export class WindowsPtyAgent {
     // Create terminal pipe IPC channel and forward to a local unix socket.
     this._outSocket = new Socket();
     this._outSocket.setEncoding('utf8');
-    this._outSocket.connect(term.conout, () => {
-      // TODO: Emit event on agent instead of socket?
-
-      // Emit ready event.
+    // The conout socket must be ready out on another thread to avoid deadlocks
+    this._conoutSocketWorker = new ConoutConnection(term.conout);
+    this._conoutSocketWorker.onReady(() => {
+      this._conoutSocketWorker.connectSocket(this._outSocket);
+    });
+    this._outSocket.on('connect', () => {
       this._outSocket.emit('ready_datapipe');
     });
 
@@ -130,7 +134,6 @@ export class WindowsPtyAgent {
       writable: true
     });
     this._inSocket.setEncoding('utf8');
-    // TODO: Wait for ready event?
 
     if (this._useConpty) {
       const connect = (this._ptyNative as IConptyNative).connect(this._pty, commandLine, cwd, env, c => this._$onProcessExit(c));
@@ -151,9 +154,7 @@ export class WindowsPtyAgent {
 
   public kill(): void {
     this._inSocket.readable = false;
-    this._inSocket.writable = false;
     this._outSocket.readable = false;
-    this._outSocket.writable = false;
     // Tell the agent to kill the pty, this releases handles to the process
     if (this._useConpty) {
       this._getConsoleProcessList().then(consoleProcessList => {
@@ -183,6 +184,7 @@ export class WindowsPtyAgent {
         }
       });
     }
+    this._conoutSocketWorker.dispose();
   }
 
   private _getConsoleProcessList(): Promise<number[]> {
@@ -238,9 +240,7 @@ export class WindowsPtyAgent {
 
   private _cleanUpProcess(): void {
     this._inSocket.readable = false;
-    this._inSocket.writable = false;
     this._outSocket.readable = false;
-    this._outSocket.writable = false;
     this._outSocket.destroy();
   }
 }

package/src/worker/conoutSocketWorker.ts

@@ -0,0 +1,18 @@
+/**
+ * Copyright (c) 2020, Microsoft Corporation (MIT License).
+ */
+
+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 conoutSocket = new Socket();
+conoutSocket.setEncoding('utf8');
+conoutSocket.connect(conoutPipeName, () => {
+  const server = createServer(workerSocket => {
+    conoutSocket.pipe(workerSocket);
+  });
+  server.listen(getWorkerPipeName(conoutPipeName));
+  parentPort.postMessage(ConoutWorkerMessage.READY);
+});

package/typings/node-pty.d.ts

@@ -42,7 +42,7 @@ declare module 'node-pty' {
     /**
      * Environment to be set for the child program.
      */
-    env?: { [key: string]: string };
+    env?: { [key: string]: string | undefined };
 
     /**
      * String encoding of the underlying pty.
@@ -78,11 +78,17 @@ declare module 'node-pty' {
 
   export interface IPtyForkOptions extends IBasePtyForkOptions {
     /**
-     * Security warning: use this option with great caution, as opened file descriptors
-     * with higher privileges might leak to the child program.
+     * Security warning: use this option with great caution unless `closeFDs` is also set,
+     * as opened file descriptors with higher privileges might leak to the child program.
      */
     uid?: number;
     gid?: number;
+
+    /**
+     * Close all open file after spawning the child process (UNIX only).
+     * Carries a performance penalty on Linux.
+     */
+    closeFDs?: boolean;
   }
 
   export interface IWindowsPtyForkOptions extends IBasePtyForkOptions {