@jingyi0605/codingns 0.8.0 → 0.8.5

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

@@ -0,0 +1,323 @@
+/**
+ * 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 os from 'os';
+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;
+
+/**
+ * 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 a common interface for both conpty
+ * and winpty.
+ */
+export class WindowsPtyAgent {
+  private _inSocket: Socket;
+  private _outSocket: Socket;
+  private _pid: number = 0;
+  private _innerPid: number = 0;
+  private _innerPidHandle: number = 0;
+  private _closeTimeout: NodeJS.Timer | undefined;
+  private _exitCode: number | undefined;
+  private _conoutSocketWorker: ConoutConnection;
+
+  private _fd: any;
+  private _pty: number;
+  private _ptyNative: IConptyNative | IWinptyNative;
+
+  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 _useConpty: boolean | undefined,
+    conptyInheritCursor: boolean = false
+  ) {
+    if (this._useConpty === undefined || this._useConpty === true) {
+      this._useConpty = this._getWindowsBuildNumber() >= 18309;
+    }
+    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;
+          }
+        }
+      }
+    } 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;
+          }
+        }
+      }
+    }
+    this._ptyNative = this._useConpty ? conptyNative : winptyNative;
+
+    // Sanitize input variable.
+    cwd = path.resolve(cwd);
+
+    // Compose command line
+    const commandLine = argsToCommandLine(file, args);
+
+    // Open pty session.
+    let term: IConptyProcess | IWinptyProcess;
+    if (this._useConpty) {
+      term = (this._ptyNative as IConptyNative).startProcess(file, cols, rows, debug, this._generatePipeName(), conptyInheritCursor);
+    } else {
+      term = (this._ptyNative as IWinptyNative).startProcess(file, commandLine, env, cwd, cols, rows, debug);
+      this._pid = (term as IWinptyProcess).pid;
+      this._innerPid = (term as IWinptyProcess).innerPid;
+      this._innerPidHandle = (term as IWinptyProcess).innerPidHandle;
+    }
+
+    // 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._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');
+
+    if (this._useConpty) {
+      const connect = (this._ptyNative as IConptyNative).connect(this._pty, commandLine, cwd, env, c => this._$onProcessExit(c));
+      this._innerPid = connect.pid;
+    }
+  }
+
+  public resize(cols: number, rows: number): void {
+    if (this._useConpty) {
+      if (this._exitCode !== undefined) {
+        throw new Error('Cannot resize a pty that has already exited');
+      }
+      this._ptyNative.resize(this._pty, cols, rows);
+      return;
+    }
+    this._ptyNative.resize(this._pid, cols, rows);
+  }
+
+  public clear(): void {
+    if (this._useConpty) {
+      (this._ptyNative as IConptyNative).clear(this._pty);
+    }
+  }
+
+  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)
+          }
+        });
+        (this._ptyNative as IConptyNative).kill(this._pty);
+      });
+    } else {
+      (this._ptyNative as IWinptyNative).kill(this._pid, this._innerPidHandle);
+      // Since pty.kill closes the handle it will kill most processes by itself
+      // and process IDs can be reused as soon as all handles to them are
+      // dropped, we want to immediately kill the entire console process list.
+      // If we do not force kill all processes here, node servers in particular
+      // seem to become detached and remain running (see
+      // Microsoft/vscode#26807).
+      const processList: number[] = (this._ptyNative as IWinptyNative).getProcessList(this._pid);
+      processList.forEach(pid => {
+        try {
+          process.kill(pid);
+        } catch (e) {
+          // Ignore if process cannot be found (kill ESRCH error)
+        }
+      });
+    }
+    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 {
+    if (this._useConpty) {
+      return this._exitCode;
+    }
+    return (this._ptyNative as IWinptyNative).getExitCode(this._innerPidHandle);
+  }
+
+  private _getWindowsBuildNumber(): number {
+    const osVersion = (/(\d+)\.(\d+)\.(\d+)/g).exec(os.release());
+    let buildNumber: number = 0;
+    if (osVersion && osVersion.length === 4) {
+      buildNumber = parseInt(osVersion[3]);
+    }
+    return buildNumber;
+  }
+
+  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;
+    this._flushDataAndCleanUp();
+    this._outSocket.on('data', () => this._flushDataAndCleanUp());
+  }
+
+  private _flushDataAndCleanUp(): void {
+    if (this._closeTimeout) {
+      clearTimeout(this._closeTimeout);
+    }
+    this._closeTimeout = setTimeout(() => this._cleanUpProcess(), FLUSH_DATA_INTERVAL);
+  }
+
+  private _cleanUpProcess(): void {
+    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/vendor/node-pty-fork/src/windowsTerminal.test.ts

@@ -0,0 +1,214 @@
+/**
+ * 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));
+        pids.forEach(pid => {
+          if (desiredState[pid]) {
+            if (!ps.some(p => p.pid === pid)) {
+              success = false;
+            }
+          } else {
+            if (ps.some(p => p.pid === pid)) {
+              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);
+        }
+        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') {
+  describe('WindowsTerminal', () => {
+    describe('kill', () => {
+      it('should not crash parent process', (done) => {
+        const term = new WindowsTerminal('cmd.exe', [], {});
+        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', [], {});
+        // 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 => {
+          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');
+          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();
+          });
+        });
+      });
+    });
+
+    describe('resize', () => {
+      it('should throw a non-native exception when resizing an invalid value', () => {
+        const term = new WindowsTerminal('cmd.exe', [], {});
+        assert.throws(() => term.resize(-1, -1));
+        assert.throws(() => term.resize(0, 0));
+        assert.doesNotThrow(() => term.resize(1, 1));
+      });
+      it('should throw an non-native exception when resizing a killed terminal', (done) => {
+        const term = new WindowsTerminal('cmd.exe', [], {});
+        (<any>term)._defer(() => {
+          term.on('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', (done) => {
+        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"', {});
+        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', (done) => {
+        const term = new WindowsTerminal('cmd.exe', '/C echo %FOO%', { 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', (done) => {
+        const term = new WindowsTerminal('cmd.exe', '/C exit');
+        term.on('exit', (code) => {
+          assert.equal(code, 0);
+          done();
+        });
+      });
+
+      it('should return process non-zero exit codes', (done) => {
+        const term = new WindowsTerminal('cmd.exe', '/C exit 2');
+        term.on('exit', (code) => {
+          assert.equal(code, 2);
+          done();
+        });
+      });
+    });
+
+    describe('winpty', () => {
+      it('should accept input', (done) => {
+        const term = new WindowsTerminal('cmd.exe', '', { useConpty: false });
+        term.write('exit\r');
+        term.on('exit', () => {
+          done();
+        });
+      });
+    });
+  });
+}