bdy 1.24.2 → 1.24.4-beta

package/distTs/package.json

@@ -1,7 +1,7 @@
 {
   "name": "bdy",
   "preferGlobal": false,
-  "version": "1.24.2",
+  "version": "1.24.4-beta",
   "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/logger.js

@@ -12,6 +12,7 @@ class Logger {
     logPath = null;
     log1Path = null;
     logStream = null;
+    dest = null;
     p = null;
     ts = null;
     constructor() {
@@ -86,6 +87,24 @@ class Logger {
             if (this.logPath)
                 this.applyLogRights(this.logPath);
             const pino = require('pino');
+            // Not stdout as a fallback: it is machine-read by `--format json` and the mcp command.
+            // `sync`, which pino.destination(fd) does not default to: an asynchronous destination
+            // buffers the line and writes it from the threadpool, so the tail of the log is exactly
+            // what an agent killed by its service manager - or by the crash being logged - loses,
+            // and every descriptor it still holds has to outlive whoever closes it.
+            this.dest =
+                this.logStream === null
+                    ? { write: () => { } }
+                    : pino.destination({
+                        dest: this.logStream,
+                        sync: true,
+                        minLength: 0,
+                    });
+            // A line that could not be written is not worth taking the process down for. Pino's own
+            // handler swallows EPIPE and re-emits the rest, and an EventEmitter re-emitting 'error'
+            // with nobody listening throws - so an unwritable log used to arrive as a crash.
+            // (the ternary above assigns an untyped pino value, which does not narrow the field)
+            this.dest.on?.('error', () => { });
             this.p = pino({
                 level: this.debugOn ? 'debug' : 'info',
                 timestamp: () => `, "time": "${new Date().toISOString()}"`,
@@ -95,11 +114,7 @@ class Logger {
                         level: label.toUpperCase(),
                     }),
                 },
-            }, 
-            // Not stdout as a fallback: it is machine-read by `--format json` and the mcp command
-            this.logStream === null
-                ? { write: () => { } }
-                : pino.destination(this.logStream));
+            }, this.dest);
             this.checkLogSize();
             this.ts = setInterval(() => {
                 this.checkLogSize();
@@ -122,20 +137,36 @@ class Logger {
     stack() {
         this.getPino().info(new Error().stack);
     }
+    // The descriptor belongs to the destination from the moment pino is handed one, so the close
+    // goes through the stream rather than through the number: closeSync on the number leaves a
+    // live stream holding a descriptor the kernel is free to hand to the next open - an EBADF at
+    // best, a log line in an unrelated file at worst - and pino, for a destination it opened
+    // asynchronously, flushes it again on exit. Anything still queued goes out first.
+    closeDestination() {
+        const dest = this.dest;
+        this.dest = null;
+        this.logStream = null;
+        if (!dest)
+            return;
+        try {
+            dest.flushSync?.();
+        }
+        catch {
+            // a destination that never opened, or one with nothing left to write
+        }
+        try {
+            dest.destroy?.();
+        }
+        catch {
+            // do nothing
+        }
+    }
     changeRootPath(path) {
         if (this.ts) {
             clearInterval(this.ts);
             this.ts = null;
         }
-        if (this.logStream) {
-            try {
-                fs_1.default.closeSync(this.logStream);
-            }
-            catch {
-                // do nothing
-            }
-            this.logStream = null;
-        }
+        this.closeDestination();
         this.p = null;
         this.rootPath = path;
     }

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",
+  "version": "1.24.4-beta",
   "type": "commonjs",
   "license": "MIT",
   "homepage": "https://buddy.works/docs/cli",