@vibedeckx/linux-x64 0.3.3 → 0.3.4

package/node_modules/node-pty/lib/windowsConoutConnection.js

@@ -50,25 +50,15 @@ var eventEmitter2_1 = require("./eventEmitter2");
  * the timer has started.
  */
 var 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
- */
 var ConoutConnection = /** @class */ (function () {
     function ConoutConnection(_conoutPipeName, _useConptyDll) {
         var _this = this;
         this._conoutPipeName = _conoutPipeName;
         this._useConptyDll = _useConptyDll;
         this._isDisposed = false;
+        this._isReady = false;
         this._onReady = new eventEmitter2_1.EventEmitter2();
+        this._onError = new eventEmitter2_1.EventEmitter2();
         var workerData = {
             conoutPipeName: _conoutPipeName
         };
@@ -77,18 +67,34 @@ var ConoutConnection = /** @class */ (function () {
         this._worker.on('message', function (message) {
             switch (message) {
                 case 1 /* ConoutWorkerMessage.READY */:
+                    _this._isReady = true;
                     _this._onReady.fire();
                     return;
                 default:
                     console.warn('Unexpected ConoutWorkerMessage', message);
             }
         });
+        this._worker.on('error', function (error) {
+            if (!_this._isDisposed && !_this._isReady) {
+                _this._onError.fire(error);
+            }
+        });
+        this._worker.on('exit', function (code) {
+            if (!_this._isDisposed && !_this._isReady) {
+                _this._onError.fire(new Error("Conout worker exited before connecting (code ".concat(code, ")")));
+            }
+        });
     }
     Object.defineProperty(ConoutConnection.prototype, "onReady", {
         get: function () { return this._onReady.event; },
         enumerable: false,
         configurable: true
     });
+    Object.defineProperty(ConoutConnection.prototype, "onError", {
+        get: function () { return this._onError.event; },
+        enumerable: false,
+        configurable: true
+    });
     ConoutConnection.prototype.dispose = function () {
         if (!this._useConptyDll && this._isDisposed) {
             return;

package/node_modules/node-pty/lib/windowsPtyAgent.js

@@ -21,13 +21,19 @@ var conptyNative;
  * has started.
  */
 var FLUSH_DATA_INTERVAL = 1000;
+var CONNECTION_TIMEOUT = 5000;
+var defaultWindowsPtyAgentOptions = {
+    connectionTimeout: CONNECTION_TIMEOUT,
+    conoutConnectionFactory: function (conoutPipeName, useConptyDll) { return new windowsConoutConnection_1.ConoutConnection(conoutPipeName, useConptyDll); }
+};
 /**
  * This agent sits between the WindowsTerminal class and provides an interface for conpty.
  */
 var WindowsPtyAgent = /** @class */ (function () {
-    function WindowsPtyAgent(file, args, env, cwd, cols, rows, debug, _useConptyDll, conptyInheritCursor) {
+    function WindowsPtyAgent(file, args, env, cwd, cols, rows, debug, _useConptyDll, conptyInheritCursor, options) {
         if (_useConptyDll === void 0) { _useConptyDll = false; }
         if (conptyInheritCursor === void 0) { conptyInheritCursor = false; }
+        if (options === void 0) { options = defaultWindowsPtyAgentOptions; }
         var _this = this;
         this._useConptyDll = _useConptyDll;
         this._innerPid = 0;
@@ -54,24 +60,26 @@ var WindowsPtyAgent = /** @class */ (function () {
         // We must wait for the worker to connect before calling conptyNative.connect()
         // to avoid blocking the Node.js event loop in ConnectNamedPipe.
         // See https://github.com/microsoft/node-pty/issues/763
-        this._conoutSocketWorker = new windowsConoutConnection_1.ConoutConnection(term.conout, this._useConptyDll);
+        this._conoutSocketWorker = options.conoutConnectionFactory(term.conout, this._useConptyDll);
         // Store pending connection info - we'll complete the connection when worker is ready
         this._pendingPtyInfo = { pty: this._pty, commandLine: commandLine, cwd: cwd, env: env };
-        // Timeout to ensure connection completes even if worker fails to signal ready
-        var connectionTimeout = setTimeout(function () {
-            if (_this._pendingPtyInfo) {
-                // Worker never signaled ready - complete connection anyway to avoid zombie state
-                _this._completePtyConnection();
-            }
-        }, 5000);
+        // Never call connect() before the worker is ready, as ConnectNamedPipe
+        // would block the Node.js event loop while waiting for the output client.
+        this._connectionTimeout = setTimeout(function () {
+            _this._failPtyConnection(new Error('Timed out waiting for ConPTY output worker'));
+        }, options.connectionTimeout);
         this._conoutSocketWorker.onReady(function () {
-            clearTimeout(connectionTimeout);
+            if (!_this._pendingPtyInfo) {
+                return;
+            }
+            _this._clearConnectionTimeout();
             _this._conoutSocketWorker.connectSocket(_this._outSocket);
             // Now that the worker has connected to the output pipe, we can safely call
             // conptyNative.connect() which calls ConnectNamedPipe - it won't block because
             // the client (worker) is already connected
             _this._completePtyConnection();
         });
+        this._conoutSocketWorker.onError(function (error) { return _this._failPtyConnection(error); });
         this._outSocket.on('connect', function () {
             _this._outSocket.emit('ready_datapipe');
         });
@@ -119,6 +127,7 @@ var WindowsPtyAgent = /** @class */ (function () {
         if (!this._pendingPtyInfo) {
             return;
         }
+        this._clearConnectionTimeout();
         var _b = this._pendingPtyInfo, pty = _b.pty, commandLine = _b.commandLine, cwd = _b.cwd, env = _b.env;
         this._pendingPtyInfo = undefined;
         try {
@@ -126,8 +135,8 @@ var WindowsPtyAgent = /** @class */ (function () {
             this._innerPid = connect.pid;
         }
         catch (err) {
-            // connect() runs from the conout worker's onReady callback (or its
-            // timeout fallback), so a throw here would otherwise surface as an
+            // connect() runs from the conout worker's onReady callback, so a throw
+            // here would otherwise surface as an
             // uncaughtException with no way for the consumer to observe it.
             var code = (_a = /error code: (\d+)/.exec(err.message)) === null || _a === void 0 ? void 0 : _a[1];
             this._exitCode = code ? parseInt(code, 10) : -1;
@@ -141,6 +150,28 @@ var WindowsPtyAgent = /** @class */ (function () {
             this._onError.fire(err);
         }
     };
+    WindowsPtyAgent.prototype._failPtyConnection = function (error) {
+        if (!this._pendingPtyInfo) {
+            return;
+        }
+        this._clearConnectionTimeout();
+        this._pendingPtyInfo = undefined;
+        this._exitCode = -1;
+        try {
+            this._ptyNative.kill(this._pty, this._useConptyDll);
+        }
+        catch ( /* already gone */_a) { /* already gone */ }
+        this._conoutSocketWorker.dispose();
+        this._inSocket.destroy();
+        this._outSocket.destroy();
+        this._onError.fire(error);
+    };
+    WindowsPtyAgent.prototype._clearConnectionTimeout = function () {
+        if (this._connectionTimeout) {
+            clearTimeout(this._connectionTimeout);
+            this._connectionTimeout = undefined;
+        }
+    };
     WindowsPtyAgent.prototype.resize = function (cols, rows) {
         if (this._exitCode !== undefined) {
             throw new Error('Cannot resize a pty that has already exited');
@@ -153,6 +184,7 @@ var WindowsPtyAgent = /** @class */ (function () {
     WindowsPtyAgent.prototype.kill = function () {
         var _this = this;
         // Prevent deferred connection from completing after kill
+        this._clearConnectionTimeout();
         this._pendingPtyInfo = undefined;
         // Tell the agent to kill the pty, this releases handles to the process
         if (!this._useConptyDll) {

package/node_modules/node-pty/package.json

@@ -4,7 +4,7 @@
   "author": {
     "name": "Microsoft Corporation"
   },
-  "version": "1.2.0-beta.14",
+  "version": "1.2.0-beta.15",
   "license": "MIT",
   "main": "./lib/index.js",
   "types": "./typings/node-pty.d.ts",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vibedeckx/linux-x64",
-  "version": "0.3.3",
+  "version": "0.3.4",
   "description": "Vibedeckx platform binaries for Linux x64",
   "os": [
     "linux"