@fenwave/agent 1.1.0

package/docker-actions/terminal.js

@@ -0,0 +1,247 @@
+import { docker } from './containers.js';
+import { v4 as uuidv4 } from 'uuid';
+import { PassThrough } from 'stream';
+
+async function handleTerminalAction(
+  ws,
+  clientId,
+  action,
+  payload,
+  terminalSessions
+) {
+  switch (action) {
+    case 'openTerminalSession':
+      return await handleOpenTerminalSession(ws, payload, terminalSessions);
+    case 'closeTerminalSession':
+      return await handleCloseTerminalSession(ws, payload, terminalSessions);
+    case 'sendTerminalInput':
+      return await handleSendTerminalInput(ws, payload, terminalSessions);
+    case 'resizeTerminal':
+      return await handleResizeTerminal(ws, payload, terminalSessions);
+    default:
+      throw new Error(`Unknown terminal action: ${action}`);
+  }
+}
+
+async function handleOpenTerminalSession(ws, payload, terminalSessions) {
+  try {
+    const { containerId, requestId } = payload;
+    const sessionId = `term-${uuidv4()}`;
+
+    const container = docker.getContainer(containerId);
+    const exec = await container.exec({
+      AttachStdin: true,
+      AttachStdout: true,
+      AttachStderr: true,
+      Tty: true,
+      Cmd: ['/bin/sh'],
+    });
+
+    const stream = await exec.start({
+      hijack: true,
+      stdin: true,
+    });
+
+    // Store the session with the exec instance
+    terminalSessions.set(sessionId, {
+      stream,
+      exec,
+      containerId,
+      lastActivity: Date.now(),
+    });
+
+    // Use docker.modem.demuxStream to properly handle the stream
+    const stdout = new PassThrough();
+    const stderr = new PassThrough();
+
+    // Handle stdout data
+    stdout.on('data', (chunk) => {
+      ws.send(
+        JSON.stringify({
+          type: 'terminalOutput',
+          sessionId,
+          output: chunk.toString(),
+        })
+      );
+    });
+
+    // Handle stderr data
+    stderr.on('data', (chunk) => {
+      ws.send(
+        JSON.stringify({
+          type: 'terminalOutput',
+          sessionId,
+          output: chunk.toString(),
+        })
+      );
+    });
+
+    // Demux the stream to remove Docker's multiplexing headers
+    docker.modem.demuxStream(stream, stdout, stderr);
+
+    // Handle stream end
+    stream.on('end', () => {
+      terminalSessions.delete(sessionId);
+      ws.send(
+        JSON.stringify({
+          type: 'terminalEnded',
+          sessionId,
+        })
+      );
+    });
+
+    // Handle stream error
+    stream.on('error', (error) => {
+      console.error('Terminal stream error:', error);
+      terminalSessions.delete(sessionId);
+      ws.send(
+        JSON.stringify({
+          type: 'error',
+          error: 'Terminal error: ' + error.message,
+          sessionId,
+        })
+      );
+    });
+
+    ws.send(
+      JSON.stringify({
+        type: 'terminalOpened',
+        sessionId,
+        containerId,
+        requestId,
+      })
+    );
+  } catch (error) {
+    console.error('Error opening terminal session:', error);
+    ws.send(
+      JSON.stringify({
+        type: 'error',
+        error: 'Failed to open terminal session: ' + error.message,
+        requestId: payload.requestId,
+      })
+    );
+  }
+}
+
+async function handleCloseTerminalSession(ws, payload, terminalSessions) {
+  try {
+    const { sessionId, requestId } = payload;
+
+    if (terminalSessions.has(sessionId)) {
+      const session = terminalSessions.get(sessionId);
+      if (session.stream.destroy) {
+        session.stream.destroy();
+      }
+      terminalSessions.delete(sessionId);
+    }
+
+    ws.send(
+      JSON.stringify({
+        type: 'terminalClosed',
+        sessionId,
+        success: true,
+        requestId,
+      })
+    );
+  } catch (error) {
+    console.error('Error closing terminal session:', error);
+    ws.send(
+      JSON.stringify({
+        type: 'error',
+        error: 'Failed to close terminal session: ' + error.message,
+        requestId: payload.requestId,
+      })
+    );
+  }
+}
+
+async function handleSendTerminalInput(ws, payload, terminalSessions) {
+  try {
+    const { sessionId, input, requestId } = payload;
+
+    if (!terminalSessions.has(sessionId)) {
+      throw new Error('Terminal session not found');
+    }
+
+    const session = terminalSessions.get(sessionId);
+    session.lastActivity = Date.now();
+    session.stream.write(input);
+
+    ws.send(
+      JSON.stringify({
+        type: 'terminalInputSent',
+        sessionId,
+        success: true,
+        requestId,
+      })
+    );
+  } catch (error) {
+    console.error('Error sending terminal input:', error);
+    ws.send(
+      JSON.stringify({
+        type: 'error',
+        error: 'Failed to send terminal input: ' + error.message,
+        requestId: payload.requestId,
+      })
+    );
+  }
+}
+
+async function handleResizeTerminal(ws, payload, terminalSessions) {
+  try {
+    const { sessionId, cols, rows, requestId } = payload;
+
+    if (!terminalSessions.has(sessionId)) {
+      throw new Error('Terminal session not found');
+    }
+
+    const session = terminalSessions.get(sessionId);
+    session.lastActivity = Date.now();
+
+    // Resize the terminal if the exec instance supports it
+    if (session.exec && typeof session.exec.resize === 'function') {
+      await session.exec.resize({ h: rows, w: cols });
+    }
+
+    ws.send(
+      JSON.stringify({
+        type: 'terminalResized',
+        sessionId,
+        success: true,
+        requestId,
+      })
+    );
+  } catch (error) {
+    console.error('Error resizing terminal:', error);
+    ws.send(
+      JSON.stringify({
+        type: 'error',
+        error: 'Failed to resize terminal: ' + error.message,
+        requestId: payload.requestId,
+      })
+    );
+  }
+}
+
+// Add a cleanup function for terminal sessions
+function cleanupInactiveTerminalSessions(terminalSessions) {
+  const now = Date.now();
+  const inactivityThreshold = 15 * 60 * 1000; // 15 minutes
+
+  for (const [sessionId, session] of terminalSessions.entries()) {
+    if (now - session.lastActivity > inactivityThreshold) {
+      console.log(`Cleaning up inactive terminal session: ${sessionId}`);
+      if (session.stream.destroy) {
+        session.stream.destroy();
+      }
+      terminalSessions.delete(sessionId);
+    }
+  }
+}
+
+export default { handleTerminalAction, cleanupInactiveTerminalSessions };
+
+export {
+  handleTerminalAction,
+  cleanupInactiveTerminalSessions,
+};