conductor-oss 0.18.2 → 0.18.4

package/web/.next/standalone/packages/web/src/components/sessions/terminal/terminalConstants.ts

@@ -24,8 +24,6 @@ export const RESUMABLE_STATUSES = new Set([
 export const RECONNECT_BASE_DELAY_MS = 300;
 export const RECONNECT_MAX_DELAY_MS = 1600;
 export const RENDERER_RECOVERY_THROTTLE_MS = 120;
-export const TERMINAL_WRITE_BATCH_MAX_DELAY_MS = 16;
-export const TERMINAL_HTTP_CONTROL_BATCH_MAX_DELAY_MS = 10;
 
 // Keep enough scrollback so users can scroll through recent output without
 // losing context on tab switch or mobile scroll. The backend owns the full
@@ -38,13 +36,7 @@ export const LIVE_TERMINAL_SCROLLBACK =
     ? MOBILE_TERMINAL_SCROLLBACK
     : DESKTOP_TERMINAL_SCROLLBACK;
 
-export const READ_ONLY_TERMINAL_SNAPSHOT_LINES = 10_000;
-
-export const TERMINAL_CONNECTION_CACHE_MAX_TTL_MS = 5_000;
-export const TERMINAL_CONNECTION_CACHE_MAX_ENTRIES = 2;
-export const TERMINAL_SNAPSHOT_CACHE_MAX_ENTRIES = 8;
 export const TERMINAL_UI_STATE_CACHE_MAX_ENTRIES = 4;
-export const TERMINAL_SNAPSHOT_CACHE_MAX_AGE_MS = 15 * 60 * 1000;
 export const TERMINAL_UI_STATE_CACHE_MAX_AGE_MS = 12 * 60 * 60 * 1000;
 
 export const LIVE_TERMINAL_HELPER_KEYS = [

package/web/.next/standalone/packages/web/src/components/sessions/terminal/terminalTypes.ts

@@ -27,27 +27,8 @@ export type TerminalConnectionInfo = {
   interactive: boolean;
 };
 
-export type TerminalSnapshot = {
-  snapshot: string;
-  transcript: string;
-  source: string;
-  live: boolean;
-  restored: boolean;
-  sequence: number | null;
-  modes?: import("../sessionTerminalUtils").TerminalModeState;
-};
-
 export type PreferredFocusTarget = "none" | "terminal" | "resume";
 
-export type CachedTerminalConnection = {
-  value: TerminalConnectionInfo;
-  expiresAt: number;
-};
-
-export type CachedTerminalSnapshot = TerminalSnapshot & {
-  updatedAt: number;
-};
-
 export type CachedTerminalUiState = {
   message: string;
   searchOpen: boolean;

package/web/.next/standalone/packages/web/src/components/sessions/terminal/ttydClient.ts

@@ -76,9 +76,19 @@ export class TtydClient {
 
   // Flow control state — track pending writes
   private pending = 0;
+  private paused = false;
+
+  // Write batching — accumulate output within a single animation frame
+  // and flush as one terminal.write() call to prevent mid-frame rendering.
+  private batchChunks: Uint8Array[] = [];
+  private batchBytes = 0;
+  private batchFrameId: number | null = null;
 
   private textEncoder = new TextEncoder();
   private textDecoder = new TextDecoder("utf-8", { fatal: false });
+  // Streaming decoder for terminal output — maintains state across flushes
+  // to correctly handle multi-byte UTF-8 sequences split across frames.
+  private streamDecoder = new TextDecoder("utf-8", { fatal: false });
 
   constructor(
     terminal: Terminal,
@@ -107,6 +117,12 @@ export class TtydClient {
           this.socket = null;
         }
 
+        // Reset flow control, batch state, and streaming decoder for the new connection
+        this.pending = 0;
+        this.paused = false;
+        this.cancelBatch();
+        this.streamDecoder = new TextDecoder("utf-8", { fatal: false });
+
         const wsUrl = resolveWebSocketUrl(url);
         this.socket = new WebSocket(wsUrl);
         this.socket.binaryType = "arraybuffer";
@@ -137,12 +153,16 @@ export class TtydClient {
         };
 
         this.socket.onmessage = (event) => {
+          if (typeof event.data === "string") {
+            return;
+          }
           this.handleMessage(event.data as ArrayBuffer);
         };
 
         this.socket.onclose = (event) => {
           clearTimeout(timeout);
           this.socket = null;
+          this.flushBatch(); // flush any pending output before signalling disconnect
           this.callbacks.onDisconnected?.(event.code, event.reason || "");
           // no-op if promise already resolved
           reject(new Error(`WebSocket closed: ${event.code}`));
@@ -163,6 +183,13 @@ export class TtydClient {
    * Disconnect from the WebSocket.
    */
   disconnect(): void {
+    this.flushBatch();
+    // Flush any incomplete UTF-8 bytes remaining in the streaming decoder
+    const trailing = this.streamDecoder.decode(new Uint8Array(0), { stream: false });
+    if (trailing.length > 0 && this.terminal) {
+      this.terminal.write(trailing);
+    }
+    this.cancelBatch();
     if (this.socket) {
       this.socket.onopen = null;
       this.socket.onmessage = null;
@@ -173,22 +200,40 @@ export class TtydClient {
     }
   }
 
-  /** Send keyboard input to the PTY: [INPUT='0'][payload] */
+  /**
+   * Send keyboard/paste input to the PTY: [INPUT='0'][payload]
+   *
+   * Large pastes are chunked into 4 KB frames to avoid overwhelming the PTY
+   * write buffer or hitting WebSocket frame limits — matches the reference
+   * ttyd client behaviour.
+   */
+  private static readonly INPUT_CHUNK_SIZE = 4096;
+
   sendInput(data: string | Uint8Array): void {
     if (!this.isConnected()) return;
 
-    let payload: Uint8Array;
-    if (typeof data === "string") {
-      const buffer = new Uint8Array(data.length * 3 + 1);
-      buffer[0] = CMD_INPUT;
-      const stats = this.textEncoder.encodeInto(data, buffer.subarray(1));
-      payload = buffer.subarray(0, (stats.written ?? 0) + 1);
-    } else {
-      payload = new Uint8Array(data.length + 1);
-      payload[0] = CMD_INPUT;
-      payload.set(data, 1);
+    const bytes = typeof data === "string"
+      ? this.textEncoder.encode(data)
+      : data;
+
+    // Small inputs (single keystrokes, short pastes): send in one frame.
+    if (bytes.length <= TtydClient.INPUT_CHUNK_SIZE) {
+      const frame = new Uint8Array(1 + bytes.length);
+      frame[0] = CMD_INPUT;
+      frame.set(bytes, 1);
+      this.socket?.send(frame);
+      return;
+    }
+
+    // Large pastes: chunk to avoid PTY buffer overflow.
+    for (let offset = 0; offset < bytes.length; offset += TtydClient.INPUT_CHUNK_SIZE) {
+      const end = Math.min(offset + TtydClient.INPUT_CHUNK_SIZE, bytes.length);
+      const chunk = bytes.subarray(offset, end);
+      const frame = new Uint8Array(1 + chunk.length);
+      frame[0] = CMD_INPUT;
+      frame.set(chunk, 1);
+      this.socket?.send(frame);
     }
-    this.socket?.send(payload);
   }
 
   /** Send resize request: [RESIZE='1'][JSON{columns,rows}] */
@@ -221,8 +266,8 @@ export class TtydClient {
 
     switch (cmd) {
       case CMD_OUTPUT:
-        // Terminal output — write directly with flow control
-        this.writeOutput(payload);
+        // Terminal output — accumulate into batch buffer, flush on next frame
+        this.enqueueOutput(payload);
         break;
       case CMD_SET_TITLE:
         try {
@@ -246,28 +291,68 @@ export class TtydClient {
   }
 
   /**
-   * Write output data directly to xterm.js with flow control.
-   * Decodes UTF-8 and applies backpressure via PAUSE/RESUME.
+   * Accumulate output data into the batch buffer. The batch is flushed as a
+   * single terminal.write() call on the next animation frame. This prevents
+   * xterm.js from rendering intermediate partial TUI states when the backend
+   * sends a large update as multiple WebSocket messages within one frame.
    */
-  // Whether PAUSE has been sent and we're waiting for pending to drop
-  private paused = false;
+  private enqueueOutput(data: Uint8Array): void {
+    if (!this.terminal || data.byteLength === 0) return;
+
+    // Copy the data since the underlying ArrayBuffer may be reused
+    this.batchChunks.push(new Uint8Array(data));
+    this.batchBytes += data.byteLength;
+
+    // Schedule flush on next animation frame (only once per frame)
+    if (this.batchFrameId === null) {
+      this.batchFrameId = requestAnimationFrame(() => {
+        this.batchFrameId = null;
+        this.flushBatch();
+      });
+    }
+  }
+
+  /**
+   * Flush all accumulated output to the terminal as a single write.
+   */
+  private flushBatch(): void {
+    if (this.batchChunks.length === 0 || !this.terminal) return;
 
-  private writeOutput(data: Uint8Array): void {
     const { highWater, lowWater } = this.flowControl;
 
-    if (!this.terminal) {
-      return;
+    // Combine all chunks into a single buffer
+    let combined: Uint8Array;
+    if (this.batchChunks.length === 1) {
+      combined = this.batchChunks[0]!;
+    } else {
+      combined = new Uint8Array(this.batchBytes);
+      let offset = 0;
+      for (const chunk of this.batchChunks) {
+        combined.set(chunk, offset);
+        offset += chunk.byteLength;
+      }
     }
 
-    // Write raw bytes directly to xterm.js — it handles UTF-8 internally.
-    // For small writes, use fast path (no callback overhead).
-    if (data.byteLength < 1024) {
-      this.terminal.write(data);
+    // Reset batch state before writing (in case write triggers synchronous events)
+    this.batchChunks.length = 0;
+    this.batchBytes = 0;
+
+    // Decode bytes to string using the streaming decoder. This correctly
+    // handles multi-byte UTF-8 sequences split across animation frames —
+    // the decoder buffers incomplete trailing bytes and prepends them to
+    // the next flush. Passing { stream: true } is critical; without it,
+    // split sequences produce U+FFFD replacement characters (blocks).
+    const text = this.streamDecoder.decode(combined, { stream: true });
+    if (text.length === 0) return;
+
+    // Small batches: fast path without callback overhead
+    if (text.length < 4096) {
+      this.terminal.write(text);
       return;
     }
 
-    // For larger writes, track pending with callback for flow control
-    this.terminal.write(data, () => {
+    // Large batches: track pending writes for flow control
+    this.terminal.write(text, () => {
       this.pending = Math.max(this.pending - 1, 0);
       // Send RESUME exactly once when pending drops below lowWater
       if (this.paused && this.pending < lowWater) {
@@ -283,6 +368,16 @@ export class TtydClient {
     }
   }
 
+  /** Cancel any pending batch flush. */
+  private cancelBatch(): void {
+    if (this.batchFrameId !== null) {
+      cancelAnimationFrame(this.batchFrameId);
+      this.batchFrameId = null;
+    }
+    this.batchChunks.length = 0;
+    this.batchBytes = 0;
+  }
+
   private sendPause(): void {
     if (!this.isConnected()) return;
     this.socket?.send(new Uint8Array([0x32])); // '2'

package/web/.next/standalone/packages/web/src/components/sessions/terminal/useTtydConnection.ts

@@ -19,6 +19,7 @@ export interface UseTtydConnectionOptions {
   onConnectionReady?: () => void;
   onConnectionError?: (error: Error) => void;
   onConnectionClosed?: (code: number, reason: string) => void;
+  onReconnectsExhausted?: () => void;
 }
 
 export interface UseTtydConnectionResult {
@@ -34,7 +35,7 @@ export interface UseTtydConnectionResult {
 export function useTtydConnection(
   options: UseTtydConnectionOptions
 ): UseTtydConnectionResult {
-  const { terminal, fitAddon, ptyWsUrl, enabled = true, onConnectionReady, onConnectionError, onConnectionClosed } = options;
+  const { terminal, fitAddon, ptyWsUrl, enabled = true, onConnectionReady, onConnectionError, onConnectionClosed, onReconnectsExhausted } = options;
 
   const clientRef = useRef<TtydClient | null>(null);
   const [isConnected, setIsConnected] = useState(false);
@@ -48,9 +49,11 @@ export function useTtydConnection(
   const onConnectionReadyRef = useRef(onConnectionReady);
   const onConnectionErrorRef = useRef(onConnectionError);
   const onConnectionClosedRef = useRef(onConnectionClosed);
+  const onReconnectsExhaustedRef = useRef(onReconnectsExhausted);
   onConnectionReadyRef.current = onConnectionReady;
   onConnectionErrorRef.current = onConnectionError;
   onConnectionClosedRef.current = onConnectionClosed;
+  onReconnectsExhaustedRef.current = onReconnectsExhausted;
 
   // Reset connection state when ptyWsUrl changes (new URL = fresh connection attempt)
   const prevPtyWsUrlRef = useRef(ptyWsUrl);
@@ -60,6 +63,7 @@ export function useTtydConnection(
       setError(null);
       setIsConnected(false);
       setIsConnecting(false);
+      reconnectAttemptsRef.current = 0;
     }
   }, [ptyWsUrl]);
 
@@ -106,6 +110,10 @@ export function useTtydConnection(
             reconnectTimerRef.current = null;
             setError(null); // allow auto-connect effect to fire
           }, delayMs);
+        } else if (code !== 1000) {
+          // All reconnect attempts exhausted — signal parent to refresh URL/token
+          setError(new Error("Connection lost"));
+          onReconnectsExhaustedRef.current?.();
         }
       },
       onError: (errorMsg) => {
@@ -127,17 +135,6 @@ export function useTtydConnection(
     };
   }, [enabled, terminal]);
 
-  // Wire terminal input → WebSocket
-  useEffect(() => {
-    if (!terminal || !clientRef.current) return;
-
-    const disposable = terminal.onData((data: string) => {
-      clientRef.current?.sendInput(data);
-    });
-
-    return () => disposable.dispose();
-  }, [terminal]);
-
   // Wire terminal resize → WebSocket
   useEffect(() => {
     if (!terminal || !fitAddon || !clientRef.current) return;