X-Git-Url: https://git.josue.xyz/?p=VSoRC%2F.git;a=blobdiff_plain;f=node_modules%2Fnode-pty%2Flib%2FunixTerminal.js;fp=node_modules%2Fnode-pty%2Flib%2FunixTerminal.js;h=004364d19eeb2d745dcda26a6b44db25d79bc952;hp=0000000000000000000000000000000000000000;hb=e79e4a5a87f3e84f7c1777f10a954453a69bf540;hpb=4339da12467b75fb8b6ca831f4bf0081c485ed2c diff --git a/node_modules/node-pty/lib/unixTerminal.js b/node_modules/node-pty/lib/unixTerminal.js new file mode 100644 index 0000000..004364d --- /dev/null +++ b/node_modules/node-pty/lib/unixTerminal.js @@ -0,0 +1,276 @@ +"use strict"; +var __extends = (this && this.__extends) || (function () { + var extendStatics = function (d, b) { + extendStatics = Object.setPrototypeOf || + ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) || + function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; }; + return extendStatics(d, b); + }; + return function (d, b) { + extendStatics(d, b); + function __() { this.constructor = d; } + d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __()); + }; +})(); +Object.defineProperty(exports, "__esModule", { value: true }); +/** + * Copyright (c) 2012-2015, Christopher Jeffrey (MIT License) + * Copyright (c) 2016, Daniel Imms (MIT License). + * Copyright (c) 2018, Microsoft Corporation (MIT License). + */ +var net = require("net"); +var terminal_1 = require("./terminal"); +var utils_1 = require("./utils"); +var pty; +try { + pty = require('../build/Release/pty.node'); +} +catch (outerError) { + try { + pty = 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; + } +} +var DEFAULT_FILE = 'sh'; +var DEFAULT_NAME = 'xterm'; +var DESTROY_SOCKET_TIMEOUT_MS = 200; +var UnixTerminal = /** @class */ (function (_super) { + __extends(UnixTerminal, _super); + function UnixTerminal(file, args, opt) { + var _this = _super.call(this, opt) || this; + 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 || terminal_1.DEFAULT_COLS; + _this._rows = opt.rows || terminal_1.DEFAULT_ROWS; + var uid = opt.uid || -1; + var gid = opt.gid || -1; + var env = utils_1.assign({}, opt.env); + if (opt.env === process.env) { + _this._sanitizeEnv(env); + } + var cwd = opt.cwd || process.cwd(); + var name = opt.name || env.TERM || DEFAULT_NAME; + env.TERM = name; + var parsedEnv = _this._parseEnv(env); + var encoding = (opt.encoding === undefined ? 'utf8' : opt.encoding); + var onexit = function (code, signal) { + // 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. + var timeout_1 = setTimeout(function () { + timeout_1 = null; + // Destroying the socket now will cause the close event to fire + _this._socket.destroy(); + }, DESTROY_SOCKET_TIMEOUT_MS); + _this.once('close', function () { + if (timeout_1 !== null) { + clearTimeout(timeout_1); + } + _this.emit('exit', code, signal); + }); + return; + } + _this.emit('exit', code, signal); + }; + // fork + var term = pty.fork(file, args, parsedEnv, cwd, _this._cols, _this._rows, uid, gid, (encoding === 'utf8'), onexit); + _this._socket = new PipeSocket(term.fd); + if (encoding !== null) { + _this._socket.setEncoding(encoding); + } + // setup + _this._socket.on('error', function (err) { + // 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', function () { + if (_this._emittedClose) { + return; + } + _this._emittedClose = true; + _this._close(); + _this.emit('close'); + }); + _this._forwardEvents(); + return _this; + } + Object.defineProperty(UnixTerminal.prototype, "master", { + get: function () { return this._master; }, + enumerable: true, + configurable: true + }); + Object.defineProperty(UnixTerminal.prototype, "slave", { + get: function () { return this._slave; }, + enumerable: true, + configurable: true + }); + UnixTerminal.prototype._write = function (data) { + this._socket.write(data); + }; + /** + * openpty + */ + UnixTerminal.open = function (opt) { + var self = Object.create(UnixTerminal.prototype); + opt = opt || {}; + if (arguments.length > 1) { + opt = { + cols: arguments[1], + rows: arguments[2] + }; + } + var cols = opt.cols || terminal_1.DEFAULT_COLS; + var rows = opt.rows || terminal_1.DEFAULT_ROWS; + var encoding = (opt.encoding === undefined ? 'utf8' : opt.encoding); + // open + var term = pty.open(cols, rows); + self._master = new PipeSocket(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 = null; + 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', function (err) { + self._close(); + if (self.listeners('error').length < 2) { + throw err; + } + }); + self._socket.on('close', function () { + self._close(); + }); + return self; + }; + UnixTerminal.prototype.destroy = function () { + var _this = this; + 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', function () { + _this.kill('SIGHUP'); + }); + this._socket.destroy(); + }; + UnixTerminal.prototype.kill = function (signal) { + try { + process.kill(this.pid, signal || 'SIGHUP'); + } + catch (e) { /* swallow */ } + }; + Object.defineProperty(UnixTerminal.prototype, "process", { + /** + * Gets the name of the process. + */ + get: function () { + return pty.process(this._fd, this._pty) || this._file; + }, + enumerable: true, + configurable: true + }); + /** + * TTY + */ + UnixTerminal.prototype.resize = function (cols, rows) { + 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; + }; + UnixTerminal.prototype._sanitizeEnv = function (env) { + // 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']; + }; + return UnixTerminal; +}(terminal_1.Terminal)); +exports.UnixTerminal = UnixTerminal; +/** + * Wraps net.Socket to force the handle type "PIPE" by temporarily overwriting + * tty_wrap.guessHandleType. + * See: https://github.com/chjj/pty.js/issues/103 + */ +var PipeSocket = /** @class */ (function (_super) { + __extends(PipeSocket, _super); + function PipeSocket(fd) { + var _this = this; + var _a = process.binding('pipe_wrap'), Pipe = _a.Pipe, constants = _a.constants; // tslint:disable-line + // @types/node has fd as string? https://github.com/DefinitelyTyped/DefinitelyTyped/pull/18275 + var handle = new Pipe(constants.SOCKET); + handle.open(fd); + _this = _super.call(this, { handle: handle }) || this; + return _this; + } + return PipeSocket; +}(net.Socket)); +//# sourceMappingURL=unixTerminal.js.map \ No newline at end of file