Release 1.0!!!!

backend/server.js

@@ -2,117 +2,91 @@ const WebSocket = require('ws');
 const ssh2 = require('ssh2');
 const http = require('http');
 
-// Create an HTTP server to serve WebSocket connections
 const server = http.createServer((req, res) => {
     res.writeHead(200, { 'Content-Type': 'text/plain' });
     res.end('WebSocket server is running\n');
 });
 
-// Create a WebSocket server attached to the HTTP server
 const wss = new WebSocket.Server({ server });
 
-// WebSocket connection handling
 wss.on('connection', (ws) => {
     console.log('WebSocket connection established');
 
-    let conn = null;
+    let conn = new ssh2.Client();
     let stream = null;
-    let interval = null;
+    let currentCols = 80;
+    let currentRows = 24;
+
+    const resizeTerminal = (cols, rows) => {
+        if (stream && stream.setWindow) {
+            stream.setWindow(rows, cols, rows * 100, cols * 100);  // Adjust terminal size
+            console.log(`Terminal resized successfully: cols=${cols}, rows=${rows}`);
+        }
+    };
 
     ws.on('message', (message) => {
+        const messageStr = message.toString();
+
+        let data;
         try {
-            const data = JSON.parse(message);
-
-            if (data.host && data.port && data.username && data.password) {
-                if (conn) {
-                    conn.end();
-                }
-
-                conn = new ssh2.Client();
-
-                interval = setInterval(() => {
-                    if (ws.readyState === WebSocket.OPEN) {
-                        ws.ping();
-                    } else {
-                        clearInterval(interval);
-                    }
-                }, 15000);
-
-                conn.on('ready', () => {
-                    console.log('SSH Connection established');
-                    conn.shell((err, sshStream) => {
-                        if (err) {
-                            console.log(`SSH Error: ${err}`);
-                            ws.send(`Error: ${err}`);
-                            return;
-                        }
-
-                        stream = sshStream;
-
-                        // Send stty commands for resizing rows and columns
-                        const resizeCommand = (rows, cols) => {
-                            return `stty rows ${rows} cols ${cols}\n`;
-                        };
-
-                        // Adjust terminal size once shell is ready
-                        ws.on('message', (msg) => {
-                            try {
-                                const input = JSON.parse(msg);
-                                if (input.type === 'resize') {
-                                    const resizeCmd = resizeCommand(input.rows, input.cols);
-                                    stream.write(resizeCmd);  // Resize the terminal in SSH
-                                } else {
-                                    stream.write(msg); // Regular input handling
-                                }
-                            } catch (e) {
-                                // If it's not JSON, it's a regular key press
-                                stream.write(msg);
-                            }
-                        });
-
-                        stream.on('data', (data) => {
-                            console.log(`SSH Output: ${data}`);
-                            ws.send(data.toString()); // Send the data back to the client once
-                        });
-
-                        stream.on('close', () => {
-                            console.log('SSH stream closed');
-                            conn.end();
-                        });
-
-                        // Send only the resize commands initially without `stty sane`
-                        const initialResizeCmd = resizeCommand(24, 80); // Example initial size
-                        stream.write(initialResizeCmd);  // Set terminal size
-                    });
-                }).on('error', (err) => {
-                    console.log('SSH Connection Error: ', err);
-                    ws.send(`SSH Error: ${err}`);
-                }).connect({
-                    host: data.host,
-                    port: data.port,
-                    username: data.username,
-                    password: data.password,
-                    keepaliveInterval: 10000,
-                    keepaliveCountMax: 5,
-                });
+            if (messageStr.trim().startsWith('{')) {
+                data = JSON.parse(messageStr);
+            } else if (stream && stream.writable) {
+                stream.write(messageStr);
+                return;
             }
         } catch (error) {
-            console.log('Received non-JSON message: ', message);
+            console.error('Failed to process message:', error);
+            return;
+        }
+
+        if (data?.host && data.port && data.username && data.password) {
+            conn.on('ready', () => {
+                console.log('SSH Connection established');
+                conn.shell({ term: 'xterm', cols: currentCols, rows: currentRows }, (error, newStream) => {
+                    if (error) {
+                        console.error(`SSH Shell Error: ${error}`);
+                        ws.send(`Error: Could not establish a shell: ${error.message}`);
+                        return;
+                    }
+
+                    stream = newStream;
+
+                    stream.on('data', (chunk) => {
+                        ws.send(chunk.toString());
+                    });
+
+                    stream.on('close', () => {
+                        console.log('SSH stream closed');
+                        conn.end();
+                    });
+                });
+            }).on('error', (err) => {
+                console.log('SSH Connection Error:', err);
+                ws.send(`SSH Connection Error: ${err.message}`);
+            }).connect({
+                host: data.host,
+                port: data.port,
+                username: data.username,
+                password: data.password,
+                keepaliveInterval: 10000,
+                keepaliveCountMax: 5,
+            });
+        } else if (data?.cols && data.rows) {
+            currentCols = data.cols;
+            currentRows = data.rows;
+            resizeTerminal(currentCols, currentRows);
         }
     });
 
     ws.on('close', () => {
+        console.log('WebSocket closed');
         if (conn) {
             conn.end();
         }
-        if (interval) {
-            clearInterval(interval);
-        }
-        console.log('WebSocket connection closed');
     });
 });
 
-// Start HTTP server
 server.listen(8081, () => {
-    console.log('WebSocket server listening on ws://localhost:8081');
+    console.log('WebSocket server is listening on ws://localhost:8081');
 });