bdy 1.24.2-stage → 1.24.3-dev

package/distTs/package.json

@@ -1,7 +1,7 @@
 {
   "name": "bdy",
   "preferGlobal": false,
-  "version": "1.24.2-stage",
+  "version": "1.24.3-dev",
   "type": "commonjs",
   "license": "MIT",
   "homepage": "https://buddy.works/docs/cli",

package/distTs/src/index.js

@@ -3,9 +3,17 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
+// FIRST, and it has to stay first: it raises the ssh2 channel window, and ssh2 reads that constant
+// once, when it is loaded. Any import above this line that reaches ssh2 would pin the window at
+// ssh2's 2MB default and cap every upload through a tunnel. See sshChannelWindow.ts.
+const sshChannelWindow_1 = require("./sshChannelWindow");
 const output_1 = __importDefault(require("./output"));
 const logger_1 = __importDefault(require("./logger"));
 const stream_1 = __importDefault(require("stream"));
+if (!sshChannelWindow_1.sshChannelWindow.applied) {
+    // Not fatal: uploads through a tunnel just keep ssh2's 2MB-per-round-trip ceiling.
+    logger_1.default.debug(`SSH channel window unchanged - ${sshChannelWindow_1.sshChannelWindow.reason}`);
+}
 output_1.default.muteNodeWarnings();
 stream_1.default.setDefaultHighWaterMark(false, 65536);
 process.title = 'bdy';

package/distTs/src/sshChannelWindow.js

@@ -0,0 +1,66 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.sshChannelWindow = void 0;
+// The SSH channel window, raised before anything in this process loads ssh2.
+//
+// Throughput over one SSH channel is window/RTT, and ssh2 ships a 2 MB window (lib/Channel.js) that is
+// a module constant, not an option. The agent is the RECEIVING end of an upload - data flows worker ->
+// agent - so it is this side's window that decides how fast anything can be uploaded through a tunnel.
+//
+// Measured with a real OpenSSH sftp upload through a tunnel at 60 ms RTT: 11.7 MB/s with 2 MB here,
+// 18.2 MB/s with 8 MB, against 19.0 MB/s for the same client and server with no tunnel in between - so
+// 8 MB removes almost all of the tunnel's penalty. Raising it on the WORKER alone changes nothing at
+// all (measured: still 11.7 MB/s), which is why this half exists. Past 8 MB the inner SSH becomes the
+// ceiling and there is nothing left to win: 32 MB measured 18.7 MB/s.
+//
+// Memory: a receive window only becomes resident when the consumer is slower than the sender, bounded
+// by the window per busy channel. On an agent that is a handful of channels on one machine, so there
+// is no knob here - unlike the worker, which multiplies it by every concurrent transfer on an edge and
+// reads SSH_CHANNEL_WINDOW for exactly that reason.
+const SSH_CHANNEL_WINDOW = 8 * 1024 * 1024;
+// Why a mutation rather than a patched dependency: client.js and server.js read these two constants
+// ONCE, by destructuring lib/Channel.js at module load, so replacing them before ssh2 is first
+// required is enough. And ssh2 is a bundleDependency published straight out of node_modules with
+// `npm ci --ignore-scripts`, so a patch step would be one forgotten command away from silently
+// shipping the 2 MB default - whereas this is source, and it travels with the build.
+//
+// Imported FIRST in src/index.ts, which is the only entry point (bin/cli.js requires it) and already
+// the home of process-wide setup like stream.setDefaultHighWaterMark. Requiring only Channel.js here
+// does not pull in client.js or server.js, so the constants are still unread at this point.
+// What happened, for src/index.ts to log once the logger exists. This module deliberately imports
+// NOTHING - logger pulls in ./utils, and the first import of the process reaching that far could drag
+// ssh2 in with it and silence the very thing being set here.
+exports.sshChannelWindow = { bytes: SSH_CHANNEL_WINDOW, applied: false, reason: '' };
+const applyChannelWindow = () => {
+    try {
+        // If ssh2 is already loaded the constants have been read and this can no longer take effect. It
+        // means a new module started importing ssh2 above this line - the symptom would otherwise be
+        // nothing but slower uploads.
+        if (Object.keys(require.cache).some((f) => f.includes(`ssh2${'/'}lib${'/'}client.js`))) {
+            exports.sshChannelWindow.reason = 'ssh2 was already loaded, so its constants had been read';
+            return;
+        }
+        const channel = require('ssh2/lib/Channel.js');
+        if (typeof channel.MAX_WINDOW !== 'number' || typeof channel.WINDOW_THRESHOLD !== 'number') {
+            exports.sshChannelWindow.reason = 'ssh2 no longer exposes MAX_WINDOW/WINDOW_THRESHOLD';
+            return;
+        }
+        if (SSH_CHANNEL_WINDOW < channel.MAX_WINDOW) {
+            exports.sshChannelWindow.reason = `ssh2 already defaults to ${channel.MAX_WINDOW} bytes`;
+            return;
+        }
+        channel.MAX_WINDOW = SSH_CHANNEL_WINDOW;
+        // ssh2 tops the window up once half of it is spent. Left at its own 1 MB it would top up only in
+        // the last eighth of an 8 MB window, which is exactly when a fast sender runs dry.
+        channel.WINDOW_THRESHOLD = Math.floor(SSH_CHANNEL_WINDOW / 2);
+        exports.sshChannelWindow.applied = true;
+    }
+    catch (err) {
+        // ssh2 moved, or is not resolvable from here: keep the tunnel working on ssh2's defaults rather
+        // than failing to start over a throughput knob. Recorded rather than swallowed - the symptom is
+        // otherwise nothing but slower uploads, which is how this cost went unnoticed in the first place.
+        exports.sshChannelWindow.reason = `${err?.message || err}`;
+    }
+};
+applyChannelWindow();
+exports.default = SSH_CHANNEL_WINDOW;

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "bdy",
   "preferGlobal": false,
-  "version": "1.24.2-stage",
+  "version": "1.24.3-dev",
   "type": "commonjs",
   "license": "MIT",
   "homepage": "https://buddy.works/docs/cli",