@myagentroam/marctl 0.9.120 → 0.9.121

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@myagentroam/marctl",
-  "version": "0.9.120",
+  "version": "0.9.121",
   "description": "MyAgentRoam command-line interface for authorized Node access.",
   "license": "Apache-2.0",
   "type": "module",

package/src/scp.mjs

@@ -61,13 +61,29 @@ function workerCommand(mode, file, size, metadata, preserve, sourceBasename) {
 class ByteChannel {
   #buffer = Buffer.alloc(0);
   #waiting = [];
+  #sending = new Map();
   #ended;
   #failure;
 
   constructor(send, signal) {
     this.send = (bytes) => {
       if (this.#failure) throw this.#failure;
-      return send(bytes);
+      if (this.#ended !== undefined) throw new MarctlError('Copy stream ended unexpectedly.');
+      return new Promise((resolve, reject) => {
+        this.#sending.set(reject, resolve);
+        const settle = (complete, value) => {
+          this.#sending.delete(reject);
+          complete(value);
+        };
+        try {
+          Promise.resolve(send(bytes)).then(
+            (value) => settle(resolve, value),
+            (error) => settle(reject, error)
+          );
+        } catch (error) {
+          settle(reject, error);
+        }
+      });
     };
     if (signal) {
       if (signal.aborted) this.fail(new MarctlError('Copy was interrupted.'));
@@ -92,11 +108,21 @@ class ByteChannel {
 
   finish(code) {
     this.#ended = code;
+    if (code !== 0) return this.fail(new MarctlError('Remote copy command failed.'));
+    // A successful exit confirms the worker consumed its final protocol input.
+    for (const resolve of this.#sending.values()) resolve();
+    this.#sending.clear();
     this.#wake();
   }
 
+  connectionEnded(error) {
+    if (this.#ended === undefined) this.fail(error);
+  }
+
   fail(error) {
     this.#failure ??= error;
+    for (const reject of this.#sending.keys()) reject(this.#failure);
+    this.#sending.clear();
     this.#wake();
   }
 
@@ -231,9 +257,9 @@ async function withRemoteWorker(
         }
       };
       const onError = () =>
-        channel.fail(new MarctlError(translate('errors.terminalConnectionFailed')));
+        channel.connectionEnded(new MarctlError(translate('errors.terminalConnectionFailed')));
       const onClose = () =>
-        channel.fail(new MarctlError(translate('errors.terminalConnectionLost')));
+        channel.connectionEnded(new MarctlError(translate('errors.terminalConnectionLost')));
       transport.on('message', onMessage);
       transport.on('error', onError);
       transport.on('close', onClose);

package/src/terminal-relay-sender.d.mts

@@ -0,0 +1,17 @@
+interface RelaySocket {
+  readonly readyState: number;
+  readonly bufferedAmount?: number;
+  send(value: string, callback: (error?: Error) => void): void;
+}
+
+export class TerminalRelaySender {
+  constructor(
+    socket: RelaySocket,
+    options?: {
+      readonly onPendingChange?: (keys: ReadonlySet<string>) => void;
+    }
+  );
+  send(value: string, key?: string): Promise<void>;
+  cancel(key: string): void;
+  close(error?: Error): void;
+}

package/src/terminal-relay-sender.mjs

@@ -0,0 +1,129 @@
+const MAX_PENDING_BYTES = 2 * 1024 * 1024;
+const MAX_SOCKET_BYTES = 256 * 1024;
+
+/** Shared sender for CLI input and the Node's aggregate Terminal relay output. */
+export class TerminalRelaySender {
+  #socket;
+  #onPendingChange;
+  #pending = [];
+  #pendingBytes = 0;
+  #inFlight;
+  #timer;
+  #immediate;
+  #closed = false;
+
+  constructor(socket, { onPendingChange = () => {} } = {}) {
+    this.#socket = socket;
+    this.#onPendingChange = onPendingChange;
+  }
+
+  send(value, key = '') {
+    if (this.#closed || this.#socket.readyState !== 1)
+      return Promise.reject(new Error('TERMINAL_CONNECTION_LOST'));
+    const bytes = Buffer.byteLength(value, 'utf8');
+    if (this.#pendingBytes + bytes > MAX_PENDING_BYTES)
+      return Promise.reject(
+        Object.assign(new Error('TERMINAL_RELAY_BUFFER_EXCEEDED'), {
+          code: 'TERMINAL_RELAY_BUFFER_EXCEEDED'
+        })
+      );
+    const result = new Promise((resolve, reject) => {
+      this.#pending.push({ value, key, bytes, resolve, reject });
+      this.#pendingBytes += bytes;
+    });
+    this.#pump();
+    this.#notify();
+    return result;
+  }
+
+  cancel(key) {
+    if (this.#inFlight?.key === key) {
+      this.#inFlight.cancelled = true;
+      this.#inFlight.reject(new Error('TERMINAL_ATTACH_INVALID'));
+    }
+    const kept = [];
+    for (const item of this.#pending) {
+      if (item.key !== key) kept.push(item);
+      else {
+        this.#pendingBytes -= item.bytes;
+        item.reject(new Error('TERMINAL_ATTACH_INVALID'));
+      }
+    }
+    this.#pending = kept;
+    if (kept.length === 0) this.#clearScheduled();
+    this.#notify();
+  }
+
+  close(error = new Error('TERMINAL_CONNECTION_LOST')) {
+    if (this.#closed) return;
+    this.#closed = true;
+    this.#clearScheduled();
+    this.#inFlight?.reject(error);
+    this.#inFlight = undefined;
+    for (const item of this.#pending) item.reject(error);
+    this.#pending = [];
+    this.#pendingBytes = 0;
+    this.#notify();
+  }
+
+  #pump() {
+    if (
+      this.#closed ||
+      this.#inFlight !== undefined ||
+      this.#timer !== undefined ||
+      this.#immediate !== undefined ||
+      this.#pending.length === 0
+    )
+      return;
+    if (this.#socket.readyState !== 1) {
+      this.close();
+      return;
+    }
+    const buffered = this.#socket.bufferedAmount ?? 0;
+    if (buffered > 0 && buffered + this.#pending[0].bytes > MAX_SOCKET_BYTES) {
+      // Poll only while the transport is congested; there is no throughput timer.
+      this.#timer = setTimeout(() => {
+        this.#timer = undefined;
+        this.#pump();
+        this.#notify();
+      }, 20);
+      return;
+    }
+    const item = this.#pending.shift();
+    this.#inFlight = item;
+    try {
+      this.#socket.send(item.value, (error) => {
+        if (this.#inFlight !== item) return;
+        if (error) {
+          this.close(error);
+          return;
+        }
+        this.#inFlight = undefined;
+        this.#pendingBytes -= item.bytes;
+        // Even a synchronous write callback must yield before the next frame.
+        this.#immediate = setImmediate(() => {
+          this.#immediate = undefined;
+          this.#pump();
+          this.#notify();
+        });
+        item.resolve();
+        this.#notify();
+      });
+    } catch (error) {
+      this.close(error);
+    }
+  }
+
+  #notify() {
+    const keys = new Set(this.#pending.map((item) => item.key));
+    if (this.#inFlight !== undefined && !this.#inFlight.cancelled) keys.add(this.#inFlight.key);
+    this.#onPendingChange(keys);
+  }
+
+  #clearScheduled() {
+    clearTimeout(this.#timer);
+    this.#timer = undefined;
+    clearImmediate(this.#immediate);
+    this.#immediate = undefined;
+  }
+}

package/src/terminal.mjs

@@ -1,6 +1,7 @@
 import { EventEmitter } from 'node:events';
 import { MarctlError } from './config.mjs';
 import { createTranslator } from './i18n/index.mjs';
+import { TerminalRelaySender } from './terminal-relay-sender.mjs';
 
 const MAX_INPUT_BYTES = 65536;
 const DEFAULT_ROWS = 24;
@@ -328,6 +329,7 @@ async function prepareRelayTransport({
 
 class BufferedRelayTransport extends EventEmitter {
   #socket;
+  #sender;
   #terminalId;
   #translate;
   #attached = false;
@@ -346,6 +348,7 @@ class BufferedRelayTransport extends EventEmitter {
   constructor({ socket, terminalId, translate, connectionTimeoutMs }) {
     super();
     this.#socket = socket;
+    this.#sender = new TerminalRelaySender(socket);
     this.#terminalId = terminalId;
     this.#translate = translate;
     this.#onOpen = () => {
@@ -388,6 +391,7 @@ class BufferedRelayTransport extends EventEmitter {
       else this.#fail(error);
     };
     this.#onClose = () => {
+      this.#sender.close();
       const error = new MarctlError(
         this.#translate(
           this.#attached ? 'errors.terminalConnectionLost' : 'errors.terminalAttachLost'
@@ -439,12 +443,14 @@ class BufferedRelayTransport extends EventEmitter {
 
   send(value) {
     if (this.#closed) throw new Error('TERMINAL_CONNECTION_LOST');
+    if (JSON.parse(value).type === 'input') return this.#sender.send(value);
     this.#socket.send(value);
   }
 
   close() {
     if (this.#closed) return;
     this.#closed = true;
+    this.#sender.close();
     clearTimeout(this.#openTimer);
     clearTimeout(this.#attachTimer);
     this.#socket.removeListener?.('open', this.#onOpen);
@@ -499,6 +505,7 @@ function runAttachedTerminal({
     let settled = false;
     let inputEnabled = false;
     let rawModeEnabled = false;
+    let inputTasks = 0;
 
     const cleanup = () => {
       transport.removeListener?.('message', onMessage);
@@ -529,13 +536,21 @@ function runAttachedTerminal({
     };
     const fail = (key) => finish(new MarctlError(translate(key)));
     const send = (frame) => {
-      transport.send(JSON.stringify(frame));
+      return transport.send(JSON.stringify(frame));
     };
-    const onInput = (data) => {
+    const onInput = async (data) => {
+      inputTasks += 1;
+      stdin.pause?.();
       try {
-        for (const chunk of splitInput(data)) send({ type: 'input', terminalId, data: chunk });
+        for (const chunk of splitInput(data)) {
+          if (settled) return;
+          await send({ type: 'input', terminalId, data: chunk });
+        }
       } catch {
         fail('errors.terminalInputFailed');
+      } finally {
+        inputTasks -= 1;
+        if (!settled && inputTasks === 0) stdin.resume?.();
       }
     };
     const onResize = () => {