`a27c4a6`

feat: add relay mode for deviceless machines

When a machine without physical input devices (e.g., hatake) is in
ReceivedControl and initiates a transfer to another direction, it now
enters Relaying mode instead of trying to grab local devices.

In Relaying mode, the machine forwards InputEvents from the original
controller to the new target, acting as a transparent relay. This
enables full multi-machine KVM chains where only one machine has
physical input devices.

New states and events:
- TransferState::Relaying { from, to } - receiving from one, forwarding to another
- TransferEvent::StartRelay { from, to } - begin relay mode
- TransferEvent::StopRelay - end relay mode

When the relay target returns control (Leave), the relay machine
resumes ReceivedControl from the original source.

Authored by mfwolffe <wolffemf@dukes.jmu.edu> 4 months ago

SHA: a27c4a6b574ea1070c2127c9a9775428786a3e4b
Parents: a657504
Tree: 7d25812

2 changed files

Status	File	+	-
M	`hyprkvm-daemon/src/main.rs`	29	1
M	`hyprkvm-daemon/src/transfer/manager.rs`	148	27

hyprkvm-daemon/src/main.rsmodified

      // Track which direction we're capturing for
      let mut capture_direction: Option<Direction> = None;
 +    // Track relay mode: (from, to) when forwarding input from one peer to another
 +    let mut relay_mode: Option<(Direction, Direction)> = None;
      let mut input_sequence: u64 = 0;
      // Escape key detection
                                          // Transfer complete
+                                     }
                                      Message::InputEvent(input_payload) => {
 -                                        // Inject input via emulation module
 +                                        // Check if we're in relay mode and this is from the relay source
 +                                        if let Some((relay_from, relay_to)) = relay_mode {
 +                                            if direction == relay_from {
 +                                                // Forward to relay target instead of injecting locally
 +                                                tracing::trace!("Relaying input from {:?} to {:?}", relay_from, relay_to);
 +                                                // Need to drop current borrow and get relay target
 +                                                drop(peers);
 +                                                let mut peers_guard = peers_arc.write().await;
 +                                                if let Some(target_peer) = peers_guard.get_mut(&relay_to) {
 +                                                    if let Err(e) = target_peer.send(&Message::InputEvent(input_payload)).await {
 +                                                        tracing::error!("Failed to relay input to {:?}: {}", relay_to, e);
 +                                                    }
 +                                                }
 +                                                continue; // Skip local injection
 +                                            }
 +                                        }
++
 +                                        // Normal case: inject input via emulation module
                                          if let Some(ref mut emu) = input_emulator {
                                              use hyprkvm_common::protocol::InputEventType;
                                              match input_payload.event {
                              emu.keyboard.reset_all_keys();
+                         }
+                     }
 +                    transfer::TransferEvent::StartRelay { from, to } => {
 +                        info!("Starting input relay: {:?} -> {:?}", from, to);
 +                        relay_mode = Some((from, to));
 +                        // No local device grabbing needed - we're forwarding received input
 +                    }
 +                    transfer::TransferEvent::StopRelay => {
 +                        info!("Stopping input relay");
 +                        relay_mode = None;
 +                    }
                      transfer::TransferEvent::SyncClipboardOutgoing { direction } => {
                          // Sync clipboard to the peer in the given direction
                          // Check if clipboard sync is enabled and appropriate for this event

hyprkvm-daemon/src/transfer/manager.rsmodified

          started_at: Instant,
          /// True if transfer was triggered via keyboard (Super+Arrow)
          keyboard_initiated: bool,
 +        /// If we initiated from ReceivedControl, this is the original source
 +        relay_from: Option<Direction>,
      },
 -    /// We sent control away, forwarding input
 +    /// We sent control away, forwarding input (from local devices)
      RemoteActive {
          target: Direction,
          transfer_id: u64,
          keyboard_initiated: bool,
      },
 +    /// We are relaying input from one machine to another (no local devices)
 +    Relaying {
 +        from: Direction,
 +        to: Direction,
 +        transfer_id: u64,
 +        entered_at: Instant,
 +    },
++
      /// We received control from another machine
      ReceivedControl {
          from: Direction,
          matches!(self, TransferState::RemoteActive { .. })
+     }
 +    pub fn is_relaying(&self) -> bool {
 +        matches!(self, TransferState::Relaying { .. })
 +    }
++
      pub fn is_receiving(&self) -> bool {
          matches!(self, TransferState::ReceivedControl { .. })
+     }
  /// Events from the transfer manager
  #[derive(Debug, Clone)]
  pub enum TransferEvent {
 -    /// Start capturing and forwarding input
 +    /// Start capturing and forwarding input (from local devices)
      /// `keyboard_initiated` is true if the transfer was triggered via keyboard (Super+Arrow),
      /// false if triggered via CLI or other non-keyboard means
      StartCapture { direction: Direction, keyboard_initiated: bool },
      /// Stop capturing, return to local
      StopCapture,
 +    /// Start relaying input from one direction to another (no local devices needed)
 +    /// Used when a deviceless machine needs to forward input through
 +    StartRelay { from: Direction, to: Direction },
 +    /// Stop relaying
 +    StopRelay,
      /// Start injecting received input
      StartInjection { from: Direction },
      /// Stop injecting
      ) -> Result<(), TransferError> {
          let mut state = self.state.write().await;
 -        // Only transfer from local or received state
 -        match &*state {
 -            TransferState::Local | TransferState::ReceivedControl { .. } => {}
 +        // Track if we're initiating from ReceivedControl (for relay mode)
 +        let relay_from = match &*state {
 +            TransferState::Local => None,
 +            TransferState::ReceivedControl { from, .. } => Some(*from),
              TransferState::Initiating { .. } => {
                  return Err(TransferError::AlreadyTransferring);
+             }
                      "Already in remote active state".to_string(),
                  ));
+             }
 -        }
 +            TransferState::Relaying { .. } => {
 +                return Err(TransferError::InvalidState(
 +                    "Already relaying".to_string(),
 +                ));
 +            }
 +        };
          let transfer_id = self.next_transfer_id();
              transfer_id,
              started_at: Instant::now(),
              keyboard_initiated,
 +            relay_from,
          };
          // Send Enter message
                  target,
                  transfer_id,
                  keyboard_initiated,
 +                relay_from,
                  ..
              } => {
                  if *transfer_id != ack.transfer_id {
                  if !ack.success {
                      tracing::warn!("EnterAck rejected: {:?}", ack.error);
 -                    *state = TransferState::Local;
 +                    // If we were relaying, go back to ReceivedControl
 +                    if let Some(from) = relay_from {
 +                        *state = TransferState::ReceivedControl {
 +                            from: *from,
 +                            transfer_id: *transfer_id,
 +                            entered_at: Instant::now(),
 +                        };
 +                    } else {
 +                        *state = TransferState::Local;
 +                    }
                      return Err(TransferError::Rejected(
                          ack.error.unwrap_or_else(|| "Unknown".to_string()),
                      ));
+                 }
 -                tracing::info!(
 -                    "Transfer accepted, cursor at {:?}, keyboard_initiated={}",
 -                    ack.actual_cursor_pos,
 -                    keyboard_initiated
 -                );
+-
                  let direction = *target;
                  let tid = *transfer_id;
                  let kbd_init = *keyboard_initiated;
 +                let from_dir = *relay_from;
 -                *state = TransferState::RemoteActive {
 -                    target: direction,
 -                    transfer_id: tid,
 -                    entered_at: Instant::now(),
 -                    keyboard_initiated: kbd_init,
 -                };
 +                // Check if this is a relay (initiated from ReceivedControl) or direct transfer
 +                if let Some(from) = from_dir {
 +                    tracing::info!(
 +                        "Relay transfer accepted: {:?} -> {:?}, cursor at {:?}",
 +                        from,
 +                        direction,
 +                        ack.actual_cursor_pos
 +                    );
 -                // Start capturing input
 -                self.event_tx
 -                    .send(TransferEvent::StartCapture { direction, keyboard_initiated: kbd_init })
 -                    .await
 -                    .map_err(|_| TransferError::ChannelClosed)?;
 +                    *state = TransferState::Relaying {
 +                        from,
 +                        to: direction,
 +                        transfer_id: tid,
 +                        entered_at: Instant::now(),
 +                    };
++
 +                    // Start relaying input (don't grab local devices, forward from source)
 +                    self.event_tx
 +                        .send(TransferEvent::StartRelay { from, to: direction })
 +                        .await
 +                        .map_err(|_| TransferError::ChannelClosed)?;
 +                } else {
 +                    tracing::info!(
 +                        "Transfer accepted, cursor at {:?}, keyboard_initiated={}",
 +                        ack.actual_cursor_pos,
 +                        keyboard_initiated
 +                    );
++
 +                    *state = TransferState::RemoteActive {
 +                        target: direction,
 +                        transfer_id: tid,
 +                        entered_at: Instant::now(),
 +                        keyboard_initiated: kbd_init,
 +                    };
++
 +                    // Start capturing input from local devices
 +                    self.event_tx
 +                        .send(TransferEvent::StartCapture { direction, keyboard_initiated: kbd_init })
 +                        .await
 +                        .map_err(|_| TransferError::ChannelClosed)?;
 +                }
                  // Trigger clipboard sync (if enabled, handled by main loop)
                  self.event_tx
                  // This shouldn't happen normally - they should send Leave, not Enter
                  tracing::warn!("Received Enter while in RemoteActive - unusual but accepting");
+             }
 +            TransferState::Relaying { .. } => {
 +                // We're relaying input, but receiving a new Enter
 +                // This is unusual but we'll accept it
 +                tracing::warn!("Received Enter while Relaying - unusual but accepting");
 +            }
+         }
          // Calculate actual cursor position using proper screen bounds
                  *state = TransferState::Local;
                  Ok(())
+             }
 +            TransferState::Relaying { from, transfer_id, .. } => {
 +                if *transfer_id != payload.transfer_id {
 +                    tracing::warn!("Leave transfer_id mismatch (relay)");
 +                }
++
 +                let from_dir = *from;
 +                tracing::info!("Relay target returned control, resuming ReceivedControl from {:?}", from_dir);
++
 +                // Stop relaying
 +                self.event_tx
 +                    .send(TransferEvent::StopRelay)
 +                    .await
 +                    .map_err(|_| TransferError::ChannelClosed)?;
++
 +                // Send LeaveAck to the target
 +                let direction = payload.to_direction.opposite();
 +                self.event_tx
 +                    .send(TransferEvent::SendMessage {
 +                        direction,
 +                        message: Message::LeaveAck,
 +                    })
 +                    .await
 +                    .map_err(|_| TransferError::ChannelClosed)?;
++
 +                // Resume injection from original source
 +                self.event_tx
 +                    .send(TransferEvent::StartInjection { from: from_dir })
 +                    .await
 +                    .map_err(|_| TransferError::ChannelClosed)?;
++
 +                *state = TransferState::ReceivedControl {
 +                    from: from_dir,
 +                    transfer_id: *transfer_id,
 +                    entered_at: Instant::now(),
 +                };
 +                Ok(())
 +            }
              _ => Err(TransferError::InvalidState(
 -                "Not in RemoteActive state".to_string(),
 +                "Not in RemoteActive or Relaying state".to_string(),
              )),
+         }
+     }
          let mut state = self.state.write().await;
          match &*state {
 -            TransferState::Initiating { .. } => {
 +            TransferState::Initiating { relay_from, .. } => {
                  tracing::warn!("Aborting pending transfer");
 -                *state = TransferState::Local;
 +                // If we were initiating from ReceivedControl, go back there
 +                if let Some(from) = relay_from {
 +                    *state = TransferState::ReceivedControl {
 +                        from: *from,
 +                        transfer_id: 0,
 +                        entered_at: Instant::now(),
 +                    };
 +                } else {
 +                    *state = TransferState::Local;
 +                }
+             }
              TransferState::RemoteActive { .. } => {
                  tracing::warn!("Aborting remote active state");
                  let _ = self.event_tx.send(TransferEvent::StopCapture).await;
                  *state = TransferState::Local;
+             }
 +            TransferState::Relaying { from, .. } => {
 +                tracing::warn!("Aborting relay state");
 +                let _ = self.event_tx.send(TransferEvent::StopRelay).await;
 +                // Go back to receiving from original source
 +                *state = TransferState::ReceivedControl {
 +                    from: *from,
 +                    transfer_id: 0,
 +                    entered_at: Instant::now(),
 +                };
 +            }
              TransferState::ReceivedControl { .. } => {
                  tracing::warn!("Aborting received control state");
                  let _ = self.event_tx.send(TransferEvent::StopInjection).await;