node-pty 1.2.0-beta.7 → 1.2.0-beta.9

package/src/windowsPtyAgent.ts

@@ -1,261 +0,0 @@
-/**
- * Copyright (c) 2012-2015, Christopher Jeffrey, Peter Sunde (MIT License)
- * Copyright (c) 2016, Daniel Imms (MIT License).
- * Copyright (c) 2018, Microsoft Corporation (MIT License).
- */
-
-import * as fs from 'fs';
-import * as path from 'path';
-import { fork } from 'child_process';
-import { Socket } from 'net';
-import { ArgvOrCommandLine } from './types';
-import { ConoutConnection } from './windowsConoutConnection';
-import { loadNativeModule } from './utils';
-
-let conptyNative: IConptyNative;
-
-/**
- * The amount of time to wait for additional data after the conpty shell process has exited before
- * 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 = 1000;
-
-/**
- * This agent sits between the WindowsTerminal class and provides an interface for conpty.
- */
-export class WindowsPtyAgent {
-  private _inSocket: Socket;
-  private _outSocket: Socket;
-  private _innerPid: number = 0;
-  private _closeTimeout: NodeJS.Timer | undefined;
-  private _exitCode: number | undefined;
-  private _conoutSocketWorker: ConoutConnection;
-
-  private _fd: any;
-  private _pty: number;
-  private _ptyNative: IConptyNative;
-
-  public get inSocket(): Socket { return this._inSocket; }
-  public get outSocket(): Socket { return this._outSocket; }
-  public get fd(): any { return this._fd; }
-  public get innerPid(): number { return this._innerPid; }
-  public get pty(): number { return this._pty; }
-
-  constructor(
-    file: string,
-    args: ArgvOrCommandLine,
-    env: string[],
-    cwd: string,
-    cols: number,
-    rows: number,
-    debug: boolean,
-    private _useConptyDll: boolean = false,
-    conptyInheritCursor: boolean = false
-  ) {
-    if (!conptyNative) {
-      conptyNative = loadNativeModule('conpty').module;
-    }
-    this._ptyNative = conptyNative;
-
-    // Sanitize input variable.
-    cwd = path.resolve(cwd);
-
-    // Compose command line
-    const commandLine = argsToCommandLine(file, args);
-
-    // Open pty session.
-    const term: IConptyProcess = conptyNative.startProcess(file, cols, rows, debug, this._generatePipeName(), conptyInheritCursor, this._useConptyDll);
-
-    // Not available on windows.
-    this._fd = term.fd;
-
-    // Generated incremental number that has no real purpose besides  using it
-    // as a terminal id.
-    this._pty = term.pty;
-
-    // Create terminal pipe IPC channel and forward to a local unix socket.
-    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._useConptyDll);
-    this._conoutSocketWorker.onReady(() => {
-      this._conoutSocketWorker.connectSocket(this._outSocket);
-    });
-    this._outSocket.on('connect', () => {
-      this._outSocket.emit('ready_datapipe');
-    });
-
-    const inSocketFD = fs.openSync(term.conin, 'w');
-    this._inSocket = new Socket({
-      fd: inSocketFD,
-      readable: false,
-      writable: true
-    });
-    this._inSocket.setEncoding('utf8');
-
-    const connect = conptyNative.connect(this._pty, commandLine, cwd, env, this._useConptyDll, c => this._$onProcessExit(c));
-    this._innerPid = connect.pid;
-  }
-
-  public resize(cols: number, rows: number): void {
-    if (this._exitCode !== undefined) {
-      throw new Error('Cannot resize a pty that has already exited');
-    }
-    this._ptyNative.resize(this._pty, cols, rows, this._useConptyDll);
-  }
-
-  public clear(): void {
-    this._ptyNative.clear(this._pty, this._useConptyDll);
-  }
-
-  public kill(): void {
-    // Tell the agent to kill the pty, this releases handles to the process
-    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.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.kill(this._pty, this._useConptyDll);
-      this._outSocket.on('data', () => {
-        this._conoutSocketWorker.dispose();
-      });
-    }
-  }
-
-  private _getConsoleProcessList(): Promise<number[]> {
-    return new Promise<number[]>(resolve => {
-      const agent = fork(path.join(__dirname, 'conpty_console_list_agent'), [ this._innerPid.toString() ]);
-      agent.on('message', message => {
-        clearTimeout(timeout);
-        resolve(message.consoleProcessList);
-      });
-      const timeout = setTimeout(() => {
-        // Something went wrong, just send back the shell PID
-        agent.kill();
-        resolve([ this._innerPid ]);
-      }, 5000);
-    });
-  }
-
-  public get exitCode(): number | undefined {
-    return this._exitCode;
-  }
-
-  private _generatePipeName(): string {
-    return `conpty-${Math.random() * 10000000}`;
-  }
-
-  /**
-   * Triggered from the native side when a contpy process exits.
-   */
-  private _$onProcessExit(exitCode: number): void {
-    this._exitCode = exitCode;
-    if (!this._useConptyDll) {
-      this._flushDataAndCleanUp();
-      this._outSocket.on('data', () => this._flushDataAndCleanUp());
-    }
-  }
-
-  private _flushDataAndCleanUp(): void {
-    if (this._useConptyDll) {
-      return;
-    }
-    if (this._closeTimeout) {
-      clearTimeout(this._closeTimeout);
-    }
-    this._closeTimeout = setTimeout(() => this._cleanUpProcess(), FLUSH_DATA_INTERVAL);
-  }
-
-  private _cleanUpProcess(): void {
-    if (this._useConptyDll) {
-      return;
-    }
-    this._inSocket.readable = false;
-    this._outSocket.readable = false;
-    this._outSocket.destroy();
-  }
-}
-
-// Convert argc/argv into a Win32 command-line following the escaping convention
-// documented on MSDN (e.g. see CommandLineToArgvW documentation). Copied from
-// winpty project.
-export function argsToCommandLine(file: string, args: ArgvOrCommandLine): string {
-  if (isCommandLine(args)) {
-    if (args.length === 0) {
-      return file;
-    }
-    return `${argsToCommandLine(file, [])} ${args}`;
-  }
-  const argv = [file];
-  Array.prototype.push.apply(argv, args);
-  let result = '';
-  for (let argIndex = 0; argIndex < argv.length; argIndex++) {
-    if (argIndex > 0) {
-      result += ' ';
-    }
-    const arg = argv[argIndex];
-    // if it is empty or it contains whitespace and is not already quoted
-    const hasLopsidedEnclosingQuote = xOr((arg[0] !== '"'), (arg[arg.length - 1] !== '"'));
-    const hasNoEnclosingQuotes = ((arg[0] !== '"') && (arg[arg.length - 1] !== '"'));
-    const quote =
-      arg === '' ||
-      (arg.indexOf(' ') !== -1 ||
-      arg.indexOf('\t') !== -1) &&
-      ((arg.length > 1) &&
-      (hasLopsidedEnclosingQuote || hasNoEnclosingQuotes));
-    if (quote) {
-      result += '\"';
-    }
-    let bsCount = 0;
-    for (let i = 0; i < arg.length; i++) {
-      const p = arg[i];
-      if (p === '\\') {
-        bsCount++;
-      } else if (p === '"') {
-        result += repeatText('\\', bsCount * 2 + 1);
-        result += '"';
-        bsCount = 0;
-      } else {
-        result += repeatText('\\', bsCount);
-        bsCount = 0;
-        result += p;
-      }
-    }
-    if (quote) {
-      result += repeatText('\\', bsCount * 2);
-      result += '\"';
-    } else {
-      result += repeatText('\\', bsCount);
-    }
-  }
-  return result;
-}
-
-function isCommandLine(args: ArgvOrCommandLine): args is string {
-  return typeof args === 'string';
-}
-
-function repeatText(text: string, count: number): string {
-  let result = '';
-  for (let i = 0; i < count; i++) {
-    result += text;
-  }
-  return result;
-}
-
-function xOr(arg1: boolean, arg2: boolean): boolean {
-  return ((arg1 && !arg2) || (!arg1 && arg2));
-}

package/src/windowsTerminal.test.ts

@@ -1,229 +0,0 @@
-/**
- * Copyright (c) 2017, Daniel Imms (MIT License).
- * Copyright (c) 2018, Microsoft Corporation (MIT License).
- */
-
-import * as fs from 'fs';
-import * as assert from 'assert';
-import { WindowsTerminal } from './windowsTerminal';
-import * as path from 'path';
-import * as psList from 'ps-list';
-
-interface IProcessState {
-  // Whether the PID must exist or must not exist
-  [pid: number]: boolean;
-}
-
-interface IWindowsProcessTreeResult {
-  name: string;
-  pid: number;
-}
-
-function pollForProcessState(desiredState: IProcessState, intervalMs: number = 100, timeoutMs: number = 2000): Promise<void> {
-  return new Promise<void>(resolve => {
-    let tries = 0;
-    const interval = setInterval(() => {
-      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;
-            }
-          }
-        });
-        if (success) {
-          clearInterval(interval);
-          resolve();
-          return;
-        }
-        tries++;
-        if (tries * intervalMs >= timeoutMs) {
-          clearInterval(interval);
-          const processListing = pids.map(k => `${k}: ${desiredState[k]}`).join('\n');
-          assert.fail(`Bad process state, expected:\n${processListing}`);
-          resolve();
-        }
-      });
-    }, intervalMs);
-  });
-}
-
-function pollForProcessTreeSize(pid: number, size: number, intervalMs: number = 100, timeoutMs: number = 2000): Promise<IWindowsProcessTreeResult[]> {
-  return new Promise<IWindowsProcessTreeResult[]>(resolve => {
-    let tries = 0;
-    const interval = setInterval(() => {
-      psList({ all: true }).then(ps => {
-        const openList: IWindowsProcessTreeResult[] = [];
-        openList.push(ps.filter(p => p.pid === pid).map(p => {
-          return { name: p.name, pid: p.pid };
-        })[0]);
-        const list: IWindowsProcessTreeResult[] = [];
-        while (openList.length) {
-          const current = openList.shift()!;
-          ps.filter(p => p.ppid === current.pid).map(p => {
-            return { name: p.name, pid: p.pid };
-          }).forEach(p => openList.push(p));
-          list.push(current);
-        }
-        console.log('list', JSON.stringify(list));
-        const success = list.length === size;
-        if (success) {
-          clearInterval(interval);
-          resolve(list);
-          return;
-        }
-        tries++;
-        if (tries * intervalMs >= timeoutMs) {
-          clearInterval(interval);
-          assert.fail(`Bad process state, expected: ${size}, actual: ${list.length}`);
-        }
-      });
-    }, intervalMs);
-  });
-}
-
-if (process.platform === 'win32') {
-  [false, true].forEach((useConptyDll) => {
-    describe(`WindowsTerminal (useConptyDll = ${useConptyDll})`, () => {
-      describe('kill', () => {
-        it('should not crash parent process', function (done) {
-          this.timeout(20000);
-          const term = new WindowsTerminal('cmd.exe', [], { useConptyDll });
-          term.on('exit', () => done());
-          term.kill();
-        });
-        it('should kill the process tree', function (done: Mocha.Done): void {
-          this.timeout(20000);
-          const term = new WindowsTerminal('cmd.exe', [], { useConptyDll });
-          // Start sub-processes
-          term.write('powershell.exe\r');
-          term.write('node.exe\r');
-          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(), 'node.exe');
-            term.kill();
-            const desiredState: IProcessState = {};
-            desiredState[list[0].pid] = false;
-            desiredState[list[1].pid] = false;
-            desiredState[list[2].pid] = false;
-            term.on('exit', () => {
-              pollForProcessState(desiredState, 1000, 5000).then(() => {
-                done();
-              }).catch(done);
-            });
-          }).catch(done);
-        });
-      });
-
-      describe('resize', () => {
-        it('should throw a non-native exception when resizing an invalid value', function(done) {
-          this.timeout(20000);
-          const term = new WindowsTerminal('cmd.exe', [], { 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', function(done) {
-          this.timeout(20000);
-          const term = new WindowsTerminal('cmd.exe', [], { useConptyDll });
-          (<any>term)._defer(() => {
-            term.once('exit', () => {
-              assert.throws(() => term.resize(1, 1));
-              done();
-            });
-            term.destroy();
-          });
-        });
-      });
-
-      describe('Args as CommandLine', () => {
-        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);
-          }
-
-          const cmdCopiedPath = path.resolve(spaceFolder, 'cmd.exe');
-          const data = fs.readFileSync(`${process.env.windir}\\System32\\cmd.exe`);
-          fs.writeFileSync(cmdCopiedPath, data);
-
-          if (!fs.existsSync(cmdCopiedPath)) {
-            // Skip test if git bash isn't installed
-            return;
-          }
-          const term = new WindowsTerminal(cmdCopiedPath, '/c echo "hello world"', { useConptyDll });
-          let result = '';
-          term.on('data', (data) => {
-            result += data;
-          });
-          term.on('exit', () => {
-            assert.ok(result.indexOf('hello world') >= 1);
-            done();
-          });
-        });
-      });
-
-      describe('env', () => {
-        it('should set environment variables of the shell', function (done) {
-          this.timeout(10000);
-          const term = new WindowsTerminal('cmd.exe', '/C echo %FOO%', { useConptyDll, env: { FOO: 'BAR' }});
-          let result = '';
-          term.on('data', (data) => {
-            result += data;
-          });
-          term.on('exit', () => {
-            assert.ok(result.indexOf('BAR') >= 0);
-            done();
-          });
-        });
-      });
-
-      describe('On close', () => {
-        it('should return process zero exit codes', function (done) {
-          this.timeout(10000);
-          const term = new WindowsTerminal('cmd.exe', '/C exit', { useConptyDll });
-          term.on('exit', (code) => {
-            assert.strictEqual(code, 0);
-            done();
-          });
-        });
-
-        it('should return process non-zero exit codes', function (done) {
-          this.timeout(10000);
-          const term = new WindowsTerminal('cmd.exe', '/C exit 2', { useConptyDll });
-          term.on('exit', (code) => {
-            assert.strictEqual(code, 2);
-            done();
-          });
-        });
-      });
-
-      describe('Write', () => {
-        it('should accept input', function (done) {
-          this.timeout(10000);
-          const term = new WindowsTerminal('cmd.exe', '', { useConptyDll });
-          term.write('exit\r');
-          term.on('exit', () => {
-            done();
-          });
-        });
-      });
-    });
-  });
-}

package/src/windowsTerminal.ts

@@ -1,203 +0,0 @@
-/**
- * Copyright (c) 2012-2015, Christopher Jeffrey, Peter Sunde (MIT License)
- * Copyright (c) 2016, Daniel Imms (MIT License).
- * Copyright (c) 2018, Microsoft Corporation (MIT License).
- */
-
-import { Socket } from 'net';
-import { Terminal, DEFAULT_COLS, DEFAULT_ROWS } from './terminal';
-import { WindowsPtyAgent } from './windowsPtyAgent';
-import { IPtyOpenOptions, IWindowsPtyForkOptions } from './interfaces';
-import { ArgvOrCommandLine } from './types';
-import { assign } from './utils';
-
-const DEFAULT_FILE = 'cmd.exe';
-const DEFAULT_NAME = 'Windows Shell';
-
-export class WindowsTerminal extends Terminal {
-  private _isReady: boolean;
-  private _deferreds: { run: () => void }[];
-  private _agent: WindowsPtyAgent;
-
-  constructor(file?: string, args?: ArgvOrCommandLine, opt?: IWindowsPtyForkOptions) {
-    super(opt);
-
-    this._checkType('args', args, 'string', true);
-
-    // Initialize arguments
-    args = args || [];
-    file = file || DEFAULT_FILE;
-    opt = opt || {};
-    opt.env = opt.env || process.env;
-
-    if (opt.encoding) {
-      console.warn('Setting encoding on Windows is not supported');
-    }
-
-    const env = assign({}, opt.env);
-    this._cols = opt.cols || DEFAULT_COLS;
-    this._rows = opt.rows || DEFAULT_ROWS;
-    const cwd = opt.cwd || process.cwd();
-    const name = opt.name || env.TERM || DEFAULT_NAME;
-    const parsedEnv = this._parseEnv(env);
-
-    // If the terminal is ready
-    this._isReady = false;
-
-    // Functions that need to run after `ready` event is emitted.
-    this._deferreds = [];
-
-    // Create new termal.
-    this._agent = new WindowsPtyAgent(file, args, parsedEnv, cwd, this._cols, this._rows, false, opt.useConptyDll, opt.conptyInheritCursor);
-    this._socket = this._agent.outSocket;
-
-    // Not available until `ready` event emitted.
-    this._pid = this._agent.innerPid;
-    this._fd = this._agent.fd;
-    this._pty = this._agent.pty;
-
-    // The forked windows terminal is not available until `ready` event is
-    // emitted.
-    this._socket.on('ready_datapipe', () => {
-
-      // 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.
-      this._socket.on('error', err => {
-        // Close terminal session.
-        this._close();
-
-        // EIO, happens when someone closes our child process: the only process
-        // in the terminal.
-        // node < 0.6.14: errno 5
-        // node >= 0.6.14: read EIO
-        if ((<any>err).code) {
-          if (~(<any>err).code.indexOf('errno 5') || ~(<any>err).code.indexOf('EIO')) return;
-        }
-
-        // Throw anything else.
-        if (this.listeners('error').length < 2) {
-          throw err;
-        }
-      });
-
-      // Cleanup after the socket is closed.
-      this._socket.on('close', () => {
-        this.emit('exit', this._agent.exitCode);
-        this._close();
-      });
-
-    });
-
-    this._file = file;
-    this._name = name;
-
-    this._readable = true;
-    this._writable = true;
-
-    this._forwardEvents();
-  }
-
-  protected _write(data: string | Buffer): void {
-    this._defer(this._doWrite, data);
-  }
-
-  private _doWrite(data: string | Buffer): void {
-    this._agent.inSocket.write(data);
-  }
-
-  /**
-   * openpty
-   */
-
-  public static open(options?: IPtyOpenOptions): void {
-    throw new Error('open() not supported on windows, use Fork() instead.');
-  }
-
-  /**
-   * TTY
-   */
-
-  public resize(cols: number, rows: number): void {
-    if (cols <= 0 || rows <= 0 || isNaN(cols) || isNaN(rows) || cols === Infinity || rows === Infinity) {
-      throw new Error('resizing must be done using positive cols and rows');
-    }
-    this._deferNoArgs(() => {
-      this._agent.resize(cols, rows);
-      this._cols = cols;
-      this._rows = rows;
-    });
-  }
-
-  public clear(): void {
-    this._deferNoArgs(() => {
-      this._agent.clear();
-    });
-  }
-
-  public destroy(): void {
-    this._deferNoArgs(() => {
-      this.kill();
-    });
-  }
-
-  public kill(signal?: string): void {
-    this._deferNoArgs(() => {
-      if (signal) {
-        throw new Error('Signals not supported on windows.');
-      }
-      this._close();
-      this._agent.kill();
-    });
-  }
-
-  private _deferNoArgs<A>(deferredFn: () => void): void {
-    // If the terminal is ready, execute.
-    if (this._isReady) {
-      deferredFn.call(this);
-      return;
-    }
-
-    // Queue until terminal is ready.
-    this._deferreds.push({
-      run: () => deferredFn.call(this)
-    });
-  }
-
-  private _defer<A>(deferredFn: (arg: A) => void, arg: A): void {
-    // If the terminal is ready, execute.
-    if (this._isReady) {
-      deferredFn.call(this, arg);
-      return;
-    }
-
-    // Queue until terminal is ready.
-    this._deferreds.push({
-      run: () => deferredFn.call(this, arg)
-    });
-  }
-
-  public get process(): string { return this._name; }
-  public get master(): Socket { throw new Error('master is not supported on Windows'); }
-  public get slave(): Socket { throw new Error('slave is not supported on Windows'); }
-}