@jingyi0605/codingns 0.8.0 → 0.8.1

package/vendor/node-pty-fork/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/vendor/node-pty-fork/src/unixTerminal.test.ts

@@ -0,0 +1,335 @@
+/**
+ * Copyright (c) 2017, Daniel Imms (MIT License).
+ * Copyright (c) 2018, Microsoft Corporation (MIT License).
+ */
+
+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'));
+
+if (process.platform !== 'win32') {
+  describe('UnixTerminal', () => {
+    describe('Constructor', () => {
+      it('should set a valid pts name', () => {
+        const term = new UnixTerminal('/bin/bash', [], {});
+        let regExp: RegExp | undefined;
+        if (process.platform === 'linux') {
+          // https://linux.die.net/man/4/pts
+          regExp = /^\/dev\/pts\/\d+$/;
+        }
+        if (process.platform === 'darwin') {
+          // https://developer.apple.com/legacy/library/documentation/Darwin/Reference/ManPages/man4/pty.4.html
+          regExp = /^\/dev\/tty[p-sP-S][a-z0-9]+$/;
+        }
+        if (regExp) {
+          assert.ok(regExp.test(term.ptsName), '"' + term.ptsName + '" should match ' + regExp.toString());
+        }
+        assert.ok(tty.isatty(term.fd));
+      });
+    });
+
+    describe('PtyForkEncodingOption', () => {
+      it('should default to utf8', (done) => {
+        const term = new UnixTerminal('/bin/bash', [ '-c', `cat "${FIXTURES_PATH}"` ]);
+        term.on('data', (data) => {
+          assert.strictEqual(typeof data, 'string');
+          assert.strictEqual(data, '\u00E6');
+          done();
+        });
+      });
+      it('should return a Buffer when encoding is null', (done) => {
+        const term = new UnixTerminal('/bin/bash', [ '-c', `cat "${FIXTURES_PATH}"` ], {
+          encoding: null
+        });
+        term.on('data', (data) => {
+          assert.strictEqual(typeof data, 'object');
+          assert.ok(data instanceof Buffer);
+          assert.strictEqual(0xC3, data[0]);
+          assert.strictEqual(0xA6, data[1]);
+          done();
+        });
+      });
+      it('should support other encodings', (done) => {
+        const text = 'test æ!';
+        const term = new UnixTerminal(undefined, ['-c', 'echo "' + text + '"'], {
+          encoding: 'base64'
+        });
+        let buffer = '';
+        term.onData((data) => {
+          assert.strictEqual(typeof data, 'string');
+          buffer += data;
+        });
+        term.onExit(() => {
+          assert.strictEqual(Buffer.alloc(8, buffer, 'base64').toString().replace('\r', '').replace('\n', ''), text);
+          done();
+        });
+      });
+    });
+
+    describe('open', () => {
+      let term: UnixTerminal;
+
+      afterEach(() => {
+        if (term) {
+          term.slave!.destroy();
+          term.master!.destroy();
+        }
+      });
+
+      it('should open a pty with access to a master and slave socket', (done) => {
+        term = UnixTerminal.open({});
+
+        let slavebuf = '';
+        term.slave!.on('data', (data) => {
+          slavebuf += data;
+        });
+
+        let masterbuf = '';
+        term.master!.on('data', (data) => {
+          masterbuf += data;
+        });
+
+        pollUntil(() => {
+          if (masterbuf === 'slave\r\nmaster\r\n' && slavebuf === 'master\n') {
+            done();
+            return true;
+          }
+          return false;
+        }, 200, 10);
+
+        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', () => {
+      it('SIGINT - custom in parent and child', done => {
+        // this test is cumbersome - we have to run it in a sub process to
+        // see behavior of SIGINT handlers
+        const data = `
+        var pty = require('./lib/index');
+        process.on('SIGINT', () => console.log('SIGINT in parent'));
+        var ptyProcess = pty.spawn('node', ['-e', 'process.on("SIGINT", ()=>console.log("SIGINT in child"));setTimeout(() => null, 300);'], {
+          name: 'xterm-color',
+          cols: 80,
+          rows: 30,
+          cwd: process.env.HOME,
+          env: process.env
+        });
+        ptyProcess.on('data', function (data) {
+          console.log(data);
+        });
+        setTimeout(() => null, 500);
+        console.log('ready', ptyProcess.pid);
+        `;
+        const buffer: string[] = [];
+        const p = cp.spawn('node', ['-e', data]);
+        let sub = '';
+        p.stdout.on('data', (data) => {
+          if (!data.toString().indexOf('ready')) {
+            sub = data.toString().split(' ')[1].slice(0, -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', () => {
+          // handlers in parent and child should have been triggered
+          assert.strictEqual(buffer.indexOf('SIGINT in child') !== -1, true);
+          assert.strictEqual(buffer.indexOf('SIGINT in parent') !== -1, true);
+          done();
+        });
+      });
+      it('SIGINT - custom in parent, default in child', done => {
+        // this tests the original idea of the signal(...) change in pty.cc:
+        // to make sure the SIGINT handler of a pty child is reset to default
+        // and does not interfere with the handler in the parent
+        const data = `
+        var pty = require('./lib/index');
+        process.on('SIGINT', () => console.log('SIGINT in parent'));
+        var ptyProcess = pty.spawn('node', ['-e', 'setTimeout(() => console.log("should not be printed"), 300);'], {
+          name: 'xterm-color',
+          cols: 80,
+          rows: 30,
+          cwd: process.env.HOME,
+          env: process.env
+        });
+        ptyProcess.on('data', function (data) {
+          console.log(data);
+        });
+        setTimeout(() => null, 500);
+        console.log('ready', ptyProcess.pid);
+        `;
+        const buffer: string[] = [];
+        const p = cp.spawn('node', ['-e', data]);
+        let sub = '';
+        p.stdout.on('data', (data) => {
+          if (!data.toString().indexOf('ready')) {
+            sub = data.toString().split(' ')[1].slice(0, -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', () => {
+          // handlers in parent and child should have been triggered
+          assert.strictEqual(buffer.indexOf('should not be printed') !== -1, false);
+          assert.strictEqual(buffer.indexOf('SIGINT in parent') !== -1, true);
+          done();
+        });
+      });
+      it('SIGHUP default (child only)', done => {
+        const term = new UnixTerminal('node', [ '-e', `
+        console.log('ready');
+        setTimeout(()=>console.log('timeout'), 200);`
+        ]);
+        let buffer = '';
+        term.on('data', (data) => {
+          if (data === 'ready\r\n') {
+            term.kill();
+          } else {
+            buffer += data;
+          }
+        });
+        term.on('exit', () => {
+          // no timeout in buffer
+          assert.strictEqual(buffer, '');
+          done();
+        });
+      });
+      it('SIGUSR1 - custom in parent and child', done => {
+        let pHandlerCalled = 0;
+        const handleSigUsr = function(h: any): any {
+          return function(): void {
+            pHandlerCalled += 1;
+            process.removeListener('SIGUSR1', h);
+          };
+        };
+        process.on('SIGUSR1', handleSigUsr(handleSigUsr));
+
+        const term = new UnixTerminal('node', [ '-e', `
+        process.on('SIGUSR1', () => {
+          console.log('SIGUSR1 in child');
+        });
+        console.log('ready');
+        setTimeout(()=>null, 200);`
+        ]);
+        let buffer = '';
+        term.on('data', (data) => {
+          if (data === 'ready\r\n') {
+            process.kill(process.pid, 'SIGUSR1');
+            term.kill('SIGUSR1');
+          } else {
+            buffer += data;
+          }
+        });
+        term.on('exit', () => {
+          // should have called both handlers and only once
+          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/vendor/node-pty-fork/src/unixTerminal.ts

@@ -0,0 +1,320 @@
+/**
+ * Copyright (c) 2012-2015, Christopher Jeffrey (MIT License)
+ * Copyright (c) 2016, Daniel Imms (MIT License).
+ * 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
+    throw outerError;
+  }
+}
+
+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;
+
+export class UnixTerminal extends Terminal {
+  protected _fd: number;
+  protected _pty: string;
+
+  protected _file: string;
+  protected _name: string;
+
+  protected _readable: boolean;
+  protected _writable: boolean;
+
+  private _boundClose: boolean = false;
+  private _emittedClose: boolean = false;
+  private _master: net.Socket | undefined;
+  private _slave: net.Socket | undefined;
+
+  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);
+
+    if (typeof args === 'string') {
+      throw new Error('args as a string is not supported on unix.');
+    }
+
+    // Initialize arguments
+    args = args || [];
+    file = file || DEFAULT_FILE;
+    opt = opt || {};
+    opt.env = opt.env || process.env;
+
+    this._cols = opt.cols || DEFAULT_COLS;
+    this._rows = opt.rows || DEFAULT_ROWS;
+    const uid = opt.uid ?? -1;
+    const gid = opt.gid ?? -1;
+    const env: IProcessEnv = assign({}, opt.env);
+
+    if (opt.env === process.env) {
+      this._sanitizeEnv(env);
+    }
+
+    const cwd = opt.cwd || process.cwd();
+    env.PWD = cwd;
+    const name = opt.name || env.TERM || DEFAULT_NAME;
+    env.TERM = name;
+    const parsedEnv = this._parseEnv(env);
+
+    const encoding = (opt.encoding === undefined ? 'utf8' : opt.encoding);
+
+    const onexit = (code: number, signal: number): void => {
+      // XXX Sometimes a data event is emitted after exit. Wait til socket is
+      // destroyed.
+      if (!this._emittedClose) {
+        if (this._boundClose) {
+          return;
+        }
+        this._boundClose = true;
+        // 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: NodeJS.Timeout | null = setTimeout(() => {
+          timeout = null;
+          // Destroying the socket now will cause the close event to fire
+          this._socket.destroy();
+        }, DESTROY_SOCKET_TIMEOUT_MS);
+        this.once('close', () => {
+          if (timeout !== null) {
+            clearTimeout(timeout);
+          }
+          this.emit('exit', code, signal);
+        });
+        return;
+      }
+      this.emit('exit', code, signal);
+    };
+
+    // fork
+    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) {
+      this._socket.setEncoding(encoding);
+    }
+
+    // setup
+    this._socket.on('error', (err: any) => {
+      // NOTE: fs.ReadStream gets EAGAIN twice at first:
+      if (err.code) {
+        if (~err.code.indexOf('EAGAIN')) {
+          return;
+        }
+      }
+
+      // close
+      this._close();
+      // EIO on exit from fs.ReadStream:
+      if (!this._emittedClose) {
+        this._emittedClose = true;
+        this.emit('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 (err.code) {
+        if (~err.code.indexOf('errno 5') || ~err.code.indexOf('EIO')) {
+          return;
+        }
+      }
+
+      // throw anything else
+      if (this.listeners('error').length < 2) {
+        throw err;
+      }
+    });
+
+    this._pid = term.pid;
+    this._fd = term.fd;
+    this._pty = term.pty;
+
+    this._file = file;
+    this._name = name;
+
+    this._readable = true;
+    this._writable = true;
+
+    this._socket.on('close', () => {
+      if (this._emittedClose) {
+        return;
+      }
+      this._emittedClose = true;
+      this._close();
+      this.emit('close');
+    });
+
+    this._forwardEvents();
+  }
+
+  protected _write(data: string): void {
+    this._socket.write(data);
+  }
+
+  /* Accessors */
+  get fd(): number { return this._fd; }
+  get ptsName(): string { return this._pty; }
+
+  /**
+   * openpty
+   */
+
+  public static open(opt: IPtyOpenOptions): UnixTerminal {
+    const self: UnixTerminal = Object.create(UnixTerminal.prototype);
+    opt = opt || {};
+
+    if (arguments.length > 1) {
+      opt = {
+        cols: arguments[1],
+        rows: arguments[2]
+      };
+    }
+
+    const cols = opt.cols || DEFAULT_COLS;
+    const rows = opt.rows || DEFAULT_ROWS;
+    const encoding = (opt.encoding === undefined ? 'utf8' : opt.encoding);
+
+    // open
+    const term: IUnixOpenProcess = pty.open(cols, rows);
+
+    self._master = new PipeSocket(<number>term.master);
+    if (encoding !== null) {
+      self._master.setEncoding(encoding);
+    }
+    self._master.resume();
+
+    self._slave = new PipeSocket(term.slave);
+    if (encoding !== null) {
+      self._slave.setEncoding(encoding);
+    }
+    self._slave.resume();
+
+    self._socket = self._master;
+    self._pid = -1;
+    self._fd = term.master;
+    self._pty = term.pty;
+
+    self._file = process.argv[0] || 'node';
+    self._name = process.env.TERM || '';
+
+    self._readable = true;
+    self._writable = true;
+
+    self._socket.on('error', err => {
+      self._close();
+      if (self.listeners('error').length < 2) {
+        throw err;
+      }
+    });
+
+    self._socket.on('close', () => {
+      self._close();
+    });
+
+    return self;
+  }
+
+  public destroy(): void {
+    this._close();
+
+    // Need to close the read stream so node stops reading a dead file
+    // descriptor. Then we can safely SIGHUP the shell.
+    this._socket.once('close', () => {
+      this.kill('SIGHUP');
+    });
+
+    this._socket.destroy();
+  }
+
+  public kill(signal?: string): void {
+    try {
+      process.kill(this.pid, signal || 'SIGHUP');
+    } catch (e) { /* swallow */ }
+  }
+
+  /**
+   * 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;
+  }
+
+  /**
+   * 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');
+    }
+    pty.resize(this._fd, cols, rows);
+    this._cols = cols;
+    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'];
+    delete env['TMUX_PANE'];
+
+    // Make sure we didn't start our server from inside screen.
+    // http://web.mit.edu/gnu/doc/html/screen_20.html
+    delete env['STY'];
+    delete env['WINDOW'];
+
+    // Delete some variables that might confuse our terminal.
+    delete env['WINDOWID'];
+    delete env['TERMCAP'];
+    delete env['COLUMNS'];
+    delete env['LINES'];
+  }
+}
+
+/**
+ * Wraps net.Socket to force the handle type "PIPE" by temporarily overwriting
+ * tty_wrap.guessHandleType.
+ * See: https://github.com/chjj/pty.js/issues/103
+ */
+class PipeSocket extends net.Socket {
+  constructor(fd: number) {
+    const pipeWrap = (<any>process).binding('pipe_wrap'); // tslint:disable-line
+    // @types/node has fd as string? https://github.com/DefinitelyTyped/DefinitelyTyped/pull/18275
+    const handle = new pipeWrap.Pipe(pipeWrap.constants.SOCKET);
+    handle.open(fd);
+    super(<any>{ handle });
+  }
+}

package/vendor/node-pty-fork/src/utils.ts

@@ -0,0 +1,9 @@
+/**
+ * Copyright (c) 2017, Daniel Imms (MIT License).
+ * Copyright (c) 2018, Microsoft Corporation (MIT License).
+ */
+
+export function assign(target: any, ...sources: any[]): any {
+  sources.forEach(source => Object.keys(source).forEach(key => target[key] = source[key]));
+  return target;
+}