Merge remote-tracking branch 'origin/website'

Author: Vierre3

server/routes/_share-terminal.ts

@@ -1,5 +1,5 @@
 import { defineWebSocketHandler } from "h3";
-import { getShare, registerTerminalPeer, unregisterTerminalPeer, broadcastToTerminalPeers, removeTerminal, addActiveTerminal, removeActiveTerminal } from "../utils/share";
+import { getShare, registerTerminalPeer, unregisterTerminalPeer, broadcastToTerminalPeers, removeTerminal, addActiveTerminal, removeActiveTerminal, updateTerminalPeerDimensions, recalcTerminalDimensions, setTerminalDimensions } from "../utils/share";
 import { createTerminalConnection } from "../utils/ssh";
 import type { Client } from "ssh2";
 
@@ -49,8 +49,10 @@ export default defineWebSocketHandler({
             const terminalId = `st-${Date.now()}-${Math.random().toString(36).slice(2, 6)}`;
             const name = `Terminal ${session.activeTerminals.size + 1}`;
 
-            // Subscribe the creator
-            registerTerminalPeer(terminalId, peer);
+            // Subscribe the creator and store their dimensions
+            const creatorDims = { cols: data.cols || 80, rows: data.rows || 24 };
+            registerTerminalPeer(terminalId, peer, creatorDims);
+            setTerminalDimensions(terminalId, creatorDims.cols, creatorDims.rows);
             let subs = peerTerminals.get(peer.id);
             if (!subs) { subs = new Set(); peerTerminals.set(peer.id, subs); }
             subs.add(terminalId);
@@ -99,14 +101,18 @@ export default defineWebSocketHandler({
             }
         } else if (data.type === "resize") {
             const { terminalId, cols, rows } = data;
-            if (typeof terminalId !== "string") return;
+            if (typeof terminalId !== "string" || typeof cols !== "number" || typeof rows !== "number") return;
+
+            // Update this peer's dimensions and compute min across all peers
+            const newMin = updateTerminalPeerDimensions(terminalId, peer.id, cols, rows);
+            if (!newMin) return; // dimensions unchanged, no PTY resize needed
 
             if (session.mode === "relay" && session.hostRelayPeer) {
-                session.hostRelayPeer.send(JSON.stringify({ type: "terminal-resize", terminalId, cols, rows }));
+                session.hostRelayPeer.send(JSON.stringify({ type: "terminal-resize", terminalId, cols: newMin.cols, rows: newMin.rows }));
             } else {
                 const dt = directTerminals.get(terminalId);
-                if (dt && dt.stream && typeof cols === "number" && typeof rows === "number") {
-                    dt.stream.setWindow(rows, cols, rows * 16, cols * 8);
+                if (dt && dt.stream) {
+                    dt.stream.setWindow(newMin.rows, newMin.cols, newMin.rows * 16, newMin.cols * 8);
                 }
             }
         } else if (data.type === "close") {
@@ -132,10 +138,24 @@ export default defineWebSocketHandler({
 });
 
 function cleanupPeer(peer: any): void {
+    const auth = peerAuth.get(peer.id);
     const subs = peerTerminals.get(peer.id);
     if (subs) {
         for (const terminalId of subs) {
             unregisterTerminalPeer(terminalId, peer);
+            // Recalculate min dimensions — the leaving peer may have been the smallest
+            const newMin = recalcTerminalDimensions(terminalId);
+            if (newMin && auth) {
+                const session = getShare(auth.shareId);
+                if (session) {
+                    if (session.mode === "relay" && session.hostRelayPeer) {
+                        session.hostRelayPeer.send(JSON.stringify({ type: "terminal-resize", terminalId, cols: newMin.cols, rows: newMin.rows }));
+                    } else {
+                        const dt = directTerminals.get(terminalId);
+                        if (dt && dt.stream) dt.stream.setWindow(newMin.rows, newMin.cols, newMin.rows * 16, newMin.cols * 8);
+                    }
+                }
+            }
         }
         peerTerminals.delete(peer.id);
     }

server/utils/share.ts

@@ -260,15 +260,20 @@ const MAX_TERMINAL_BUFFER = 50 * 1024; // 50KB rolling replay buffer per termina
 interface SharedTerminalEntry {
     peers: Set<Peer>;
     outputBuffer: string; // rolling buffer for late subscribers
+    peerDimensions: Map<string, { cols: number; rows: number }>; // peerId → last known dimensions
+    currentDimensions: { cols: number; rows: number }; // current PTY dimensions
 }
 const sharedTerminals = new Map<string, SharedTerminalEntry>();
 
-export function registerTerminalPeer(terminalId: string, peer: Peer): void {
+export function registerTerminalPeer(terminalId: string, peer: Peer, dims?: { cols: number; rows: number }): void {
     let entry = sharedTerminals.get(terminalId);
     if (!entry) {
-        entry = { peers: new Set(), outputBuffer: "" };
+        entry = { peers: new Set(), outputBuffer: "", peerDimensions: new Map(), currentDimensions: { cols: 80, rows: 24 } };
         sharedTerminals.set(terminalId, entry);
     }
+    if (dims) {
+        entry.peerDimensions.set(peer.id, dims);
+    }
     // Replay buffered output to late subscriber
     if (entry.outputBuffer.length > 0) {
         try { peer.send(JSON.stringify({ type: "output", terminalId, data: entry.outputBuffer })); } catch {}
@@ -280,6 +285,7 @@ export function unregisterTerminalPeer(terminalId: string, peer: Peer): void {
     const entry = sharedTerminals.get(terminalId);
     if (entry) {
         entry.peers.delete(peer);
+        entry.peerDimensions.delete(peer.id);
         if (entry.peers.size === 0) sharedTerminals.delete(terminalId);
     }
 }
@@ -304,6 +310,47 @@ export function removeTerminal(terminalId: string): void {
     sharedTerminals.delete(terminalId);
 }
 
+/**
+ * Update a peer's dimensions and compute the minimum across all peers.
+ * Returns the new min dimensions if they differ from the current PTY dimensions, or null if unchanged.
+ */
+export function updateTerminalPeerDimensions(terminalId: string, peerId: string, cols: number, rows: number): { cols: number; rows: number } | null {
+    const entry = sharedTerminals.get(terminalId);
+    if (!entry) return null;
+    entry.peerDimensions.set(peerId, { cols, rows });
+    const min = computeMinDimensions(entry);
+    if (min.cols === entry.currentDimensions.cols && min.rows === entry.currentDimensions.rows) return null;
+    entry.currentDimensions = min;
+    return min;
+}
+
+/**
+ * Recalculate min dimensions after a peer disconnects.
+ */
+export function recalcTerminalDimensions(terminalId: string): { cols: number; rows: number } | null {
+    const entry = sharedTerminals.get(terminalId);
+    if (!entry || entry.peerDimensions.size === 0) return null;
+    const min = computeMinDimensions(entry);
+    if (min.cols === entry.currentDimensions.cols && min.rows === entry.currentDimensions.rows) return null;
+    entry.currentDimensions = min;
+    return min;
+}
+
+function computeMinDimensions(entry: SharedTerminalEntry): { cols: number; rows: number } {
+    let minCols = Infinity;
+    let minRows = Infinity;
+    for (const dims of entry.peerDimensions.values()) {
+        if (dims.cols < minCols) minCols = dims.cols;
+        if (dims.rows < minRows) minRows = dims.rows;
+    }
+    return { cols: minCols === Infinity ? 80 : minCols, rows: minRows === Infinity ? 24 : minRows };
+}
+
+export function setTerminalDimensions(terminalId: string, cols: number, rows: number): void {
+    const entry = sharedTerminals.get(terminalId);
+    if (entry) entry.currentDimensions = { cols, rows };
+}
+
 // --- Path security ---
 
 export function isPathWithinRoot(filePath: string, rootPath: string): boolean {