[Init] Initial commit - NetMesh terminal manager

electron/bridges/keyboardInteractiveHandler.cjs

@@ -0,0 +1,156 @@
+/**
+ * Keyboard Interactive Handler - Shared state for keyboard-interactive authentication
+ * This module provides a centralized storage for keyboard-interactive auth requests
+ * used by SSH, SFTP, and Port Forwarding bridges.
+ */
+
+// Keyboard-interactive authentication pending requests
+// Map of requestId -> { finishCallback, webContentsId, sessionId, createdAt, timeoutId }
+const { randomUUID } = require("node:crypto");
+
+const keyboardInteractiveRequests = new Map();
+
+// TTL for abandoned requests (5 minutes)
+const REQUEST_TTL_MS = 5 * 60 * 1000;
+
+/**
+ * Generate a unique request ID for keyboard-interactive requests
+ */
+function generateRequestId(prefix = 'ki') {
+  return `${prefix}-${randomUUID()}`;
+}
+
+/**
+ * Store a keyboard-interactive request with TTL cleanup
+ */
+function storeRequest(requestId, finishCallback, webContentsId, sessionId, sender) {
+  // Set up TTL timeout to clean up abandoned requests
+  const timeoutId = setTimeout(() => {
+    const pending = keyboardInteractiveRequests.get(requestId);
+    if (pending) {
+      console.warn(`[KeyboardInteractive] Request ${requestId} timed out after ${REQUEST_TTL_MS / 1000}s, cleaning up`);
+      keyboardInteractiveRequests.delete(requestId);
+      // Call finish with empty responses to abort the authentication
+      try {
+        pending.finishCallback([]);
+      } catch (err) {
+        console.warn(`[KeyboardInteractive] Failed to call finishCallback for timed out request:`, err.message);
+      }
+      notifyCancellation(pending, requestId, "timeout");
+    }
+  }, REQUEST_TTL_MS);
+
+  keyboardInteractiveRequests.set(requestId, {
+    finishCallback,
+    webContentsId,
+    sessionId,
+    sender,
+    createdAt: Date.now(),
+    timeoutId,
+  });
+}
+
+/**
+ * Handle keyboard-interactive authentication response from renderer
+ */
+function handleResponse(_event, payload) {
+  console.log(`[KeyboardInteractive] handleResponse called`, {
+    requestId: payload?.requestId,
+    cancelled: Boolean(payload?.cancelled),
+    responsesCount: Array.isArray(payload?.responses) ? payload.responses.length : 0,
+  });
+
+  const { requestId, responses, cancelled } = payload;
+  const pending = keyboardInteractiveRequests.get(requestId);
+
+  console.log(`[KeyboardInteractive] Looking for request ${requestId}, found:`, !!pending);
+  console.log(`[KeyboardInteractive] Current pending requests:`, Array.from(keyboardInteractiveRequests.keys()));
+
+  if (!pending) {
+    console.warn(`[KeyboardInteractive] No pending request for ${requestId}`);
+    return { success: false, error: 'Request not found' };
+  }
+
+  if (_event?.sender?.id !== pending.webContentsId) {
+    console.warn(`[KeyboardInteractive] Wrong sender for request ${requestId}`);
+    return { success: false, error: 'Wrong sender' };
+  }
+
+  if (pending.timeoutId) clearTimeout(pending.timeoutId);
+  keyboardInteractiveRequests.delete(requestId);
+
+  try {
+    if (cancelled) {
+      console.log(`[KeyboardInteractive] Auth cancelled for ${requestId}`);
+      pending.finishCallback([]); // Empty responses to cancel
+    } else {
+      console.log(`[KeyboardInteractive] Auth response received for ${requestId}, responses count:`, responses?.length);
+      pending.finishCallback(responses);
+    }
+  } catch (err) {
+    console.warn(`[KeyboardInteractive] Failed to deliver response for ${requestId}:`, err?.message);
+    notifyCancellation(pending, requestId, "delivery-failed");
+    return { success: false, error: "Failed to deliver response" };
+  }
+
+  return { success: true };
+}
+
+/**
+ * Cancel every pending request owned by a session or external operation.
+ */
+function notifyCancellation(pending, requestId, reason) {
+  try {
+    if (!pending.sender?.isDestroyed?.()) {
+      pending.sender?.send?.("netcatty:keyboard-interactive-cancelled", {
+        requestId,
+        sessionId: pending.sessionId,
+        reason,
+      });
+    }
+  } catch (err) {
+    console.warn(`[KeyboardInteractive] Failed to notify cancellation for ${requestId}:`, err.message);
+  }
+}
+
+function cancelRequestsForSession(sessionId, reason = "cancelled") {
+  let cancelled = 0;
+  for (const [requestId, pending] of keyboardInteractiveRequests) {
+    if (pending.sessionId !== sessionId) continue;
+    if (pending.timeoutId) {
+      clearTimeout(pending.timeoutId);
+    }
+    keyboardInteractiveRequests.delete(requestId);
+    try {
+      pending.finishCallback([]);
+    } catch (err) {
+      console.warn(`[KeyboardInteractive] Failed to cancel request ${requestId}:`, err.message);
+    }
+    notifyCancellation(pending, requestId, reason);
+    cancelled += 1;
+  }
+  return cancelled;
+}
+
+/**
+ * Get the requests map (for debugging/testing)
+ */
+function getRequests() {
+  return keyboardInteractiveRequests;
+}
+
+/**
+ * Register IPC handler for keyboard-interactive responses
+ */
+function registerHandler(ipcMain) {
+  ipcMain.handle("netcatty:keyboard-interactive:respond", handleResponse);
+}
+
+module.exports = {
+  generateRequestId,
+  storeRequest,
+  handleResponse,
+  cancelRequestsForSession,
+  getRequests,
+  registerHandler,
+};