Merge 1e2cee7060 into c8dd84c6b7

cloud.go

@@ -477,7 +477,7 @@ func handleSessionRequest(
 	cloudLogger.Trace().Interface("session", session).Msg("new session accepted")
 
 	// Cancel any ongoing keyboard report multi when session changes
-	cancelKeyboardReportMulti()
+	cancelKeyboardMacro()
 
 	currentSession = session
 	_ = wsjson.Write(context.Background(), c, gin.H{"type": "answer", "data": sd})

hidrpc.go

@@ -1,7 +1,6 @@
 package kvm
 
 import (
-	"context"
 	"errors"
 	"fmt"
 	"io"
@@ -38,7 +37,10 @@ func handleHidRPCMessage(message hidrpc.Message, session *Session) {
 			logger.Warn().Err(err).Msg("failed to get keyboard macro report")
 			return
 		}
-		_, rpcErr = rpcKeyboardReportMulti(context.Background(), keyboardMacroReport.Macro)
+		_, rpcErr = rpcExecuteKeyboardMacro(keyboardMacroReport.Macro)
+	case hidrpc.TypeCancelKeyboardMacroReport:
+		rpcCancelKeyboardMacro()
+		return
 	case hidrpc.TypePointerReport:
 		pointerReport, err := message.PointerReport()
 		if err != nil {
@@ -138,6 +140,8 @@ func reportHidRPC(params any, session *Session) {
 		message, err = hidrpc.NewKeyboardLedMessage(params).Marshal()
 	case usbgadget.KeysDownState:
 		message, err = hidrpc.NewKeydownStateMessage(params).Marshal()
+	case hidrpc.KeyboardMacroStateReport:
+		message, err = hidrpc.NewKeyboardMacroStateMessage(params.State, params.IsPaste).Marshal()
 	default:
 		err = fmt.Errorf("unknown HID RPC message type: %T", params)
 	}
@@ -174,3 +178,10 @@ func (s *Session) reportHidRPCKeysDownState(state usbgadget.KeysDownState) {
 	}
 	reportHidRPC(state, s)
 }
+
+func (s *Session) reportHidRPCKeyboardMacroState(state hidrpc.KeyboardMacroStateReport) {
+	if !s.hidRPCAvailable {
+		writeJSONRPCEvent("keyboardMacroState", state, s)
+	}
+	reportHidRPC(state, s)
+}

internal/hidrpc/hidrpc.go

@@ -32,10 +32,13 @@ func GetQueueIndex(messageType MessageType) int {
 	switch messageType {
 	case TypeHandshake:
 		return 0
-	case TypeKeyboardReport, TypeKeypressReport, TypeKeyboardLedState, TypeKeydownState, TypeKeyboardMacroStateReport:
+	case TypeKeyboardReport, TypeKeypressReport, TypeKeyboardMacroReport, TypeKeyboardLedState, TypeKeydownState, TypeKeyboardMacroStateReport:
 		return 1
 	case TypePointerReport, TypeMouseReport, TypeWheelReport:
 		return 2
+	// we don't want to block the queue for this message
+	case TypeCancelKeyboardMacroReport:
+		return 3
 	default:
 		return 3
 	}
@@ -101,3 +104,19 @@ func NewKeydownStateMessage(state usbgadget.KeysDownState) *Message {
 		d: data,
 	}
 }
+
+// NewKeyboardMacroStateMessage creates a new keyboard macro state message.
+func NewKeyboardMacroStateMessage(state bool, isPaste bool) *Message {
+	data := make([]byte, 2)
+	if state {
+		data[0] = 1
+	}
+	if isPaste {
+		data[1] = 1
+	}
+
+	return &Message{
+		t: TypeKeyboardMacroStateReport,
+		d: data,
+	}
+}

internal/hidrpc/message.go

@@ -182,3 +182,20 @@ func (m *Message) MouseReport() (MouseReport, error) {
 		Button: uint8(m.d[2]),
 	}, nil
 }
+
+type KeyboardMacroStateReport struct {
+	State   bool
+	IsPaste bool
+}
+
+// KeyboardMacroStateReport returns the keyboard macro state report from the message.
+func (m *Message) KeyboardMacroStateReport() (KeyboardMacroStateReport, error) {
+	if m.t != TypeKeyboardMacroStateReport {
+		return KeyboardMacroStateReport{}, fmt.Errorf("invalid message type: %d", m.t)
+	}
+
+	return KeyboardMacroStateReport{
+		State:   m.d[0] == uint8(1),
+		IsPaste: m.d[1] == uint8(1),
+	}, nil
+}

jsonrpc.go

@@ -1,6 +1,7 @@
 package kvm
 
 import (
+	"bytes"
 	"context"
 	"encoding/json"
 	"errors"
@@ -10,6 +11,7 @@ import (
 	"path/filepath"
 	"reflect"
 	"strconv"
+	"sync"
 	"time"
 
 	"github.com/pion/webrtc/v4"
@@ -1050,85 +1052,100 @@ func rpcSetLocalLoopbackOnly(enabled bool) error {
 	return nil
 }
 
-func cancelKeyboardReportMulti() {
+var (
+	keyboardMacroCancel context.CancelFunc
+	keyboardMacroLock   sync.Mutex
+)
 
+// cancelKeyboardMacro cancels any ongoing keyboard macro execution
+func cancelKeyboardMacro() {
+	keyboardMacroLock.Lock()
+	defer keyboardMacroLock.Unlock()
+
+	if keyboardMacroCancel != nil {
+		keyboardMacroCancel()
+		logger.Info().Msg("canceled keyboard macro")
+		keyboardMacroCancel = nil
+	}
 }
 
-// // cancelKeyboardReportMulti cancels any ongoing keyboard report multi execution
+func setKeyboardMacroCancel(cancel context.CancelFunc) {
-// func cancelKeyboardReportMulti() {
+	keyboardMacroLock.Lock()
-// 	keyboardReportMultiLock.Lock()
+	defer keyboardMacroLock.Unlock()
-// 	defer keyboardReportMultiLock.Unlock()
 
-// 	if keyboardReportMultiCancel != nil {
+	keyboardMacroCancel = cancel
-// 		keyboardReportMultiCancel()
+}
-// 		logger.Info().Msg("canceled keyboard report multi")
-// 		keyboardReportMultiCancel = nil
-// 	}
-// }
 
-// func setKeyboardReportMultiCancel(cancel context.CancelFunc) {
+func rpcExecuteKeyboardMacro(macro []hidrpc.KeyboardMacro) (usbgadget.KeysDownState, error) {
-// 	keyboardReportMultiLock.Lock()
+	cancelKeyboardMacro()
-// 	defer keyboardReportMultiLock.Unlock()
 
-// 	keyboardReportMultiCancel = cancel
+	ctx, cancel := context.WithCancel(context.Background())
-// }
+	setKeyboardMacroCancel(cancel)
 
-// func rpcKeyboardReportMultiWrapper(macro []map[string]any) (usbgadget.KeysDownState, error) {
+	s := hidrpc.KeyboardMacroStateReport{
-// 	// cancelKeyboardReportMulti()
+		State:   true,
+		IsPaste: true,
+	}
 
-// 	// ctx, cancel := context.WithCancel(context.Background())
+	if currentSession != nil {
-// 	// setKeyboardReportMultiCancel(cancel)
+		currentSession.reportHidRPCKeyboardMacroState(s)
+	}
 
-// 	// writeJSONRPCEvent("keyboardReportMultiState", true, currentSession)
+	result, err := rpcDoExecuteKeyboardMacro(ctx, macro)
 
-// 	// result, err := rpcKeyboardReportMulti(ctx, macro)
+	setKeyboardMacroCancel(nil)
 
-// 	// setKeyboardReportMultiCancel(nil)
+	s.State = false
+	if currentSession != nil {
+		currentSession.reportHidRPCKeyboardMacroState(s)
+	}
 
-// 	// writeJSONRPCEvent("keyboardReportMultiState", false, currentSession)
+	return result, err
+}
 
-// 	// return result, err
+func rpcCancelKeyboardMacro() {
-// }
+	cancelKeyboardMacro()
+}
 
-// var (
+var keyboardClearStateKeys = make([]byte, 6)
-// 	keyboardReportMultiCancel context.CancelFunc
-// 	keyboardReportMultiLock   sync.Mutex
-// )
 
-// func rpcCancelKeyboardReportMulti() {
+func isClearKeyStep(step hidrpc.KeyboardMacro) bool {
-// 	cancelKeyboardReportMulti()
+	return step.Modifier == 0 && bytes.Equal(step.Keys, keyboardClearStateKeys)
-// }
+}
 
-func rpcKeyboardReportMulti(ctx context.Context, macro []hidrpc.KeyboardMacro) (usbgadget.KeysDownState, error) {
+func rpcDoExecuteKeyboardMacro(ctx context.Context, macro []hidrpc.KeyboardMacro) (usbgadget.KeysDownState, error) {
 	var last usbgadget.KeysDownState
 	var err error
 
-	logger.Debug().Interface("macro", macro).Msg("Executing keyboard report multi")
+	logger.Debug().Interface("macro", macro).Msg("Executing keyboard macro")
 
 	for i, step := range macro {
-		// Check for cancellation before each step
-		select {
-		case <-ctx.Done():
-			logger.Debug().Msg("Keyboard report multi context cancelled")
-			return last, ctx.Err()
-		default:
-		}
-
 		delay := time.Duration(step.Delay) * time.Millisecond
-		logger.Info().Int("step", i).Uint16("delay", step.Delay).Msg("Keyboard report multi delay")
 
 		last, err = rpcKeyboardReport(step.Modifier, step.Keys)
 		if err != nil {
-			logger.Warn().Err(err).Msg("failed to execute keyboard report multi")
+			logger.Warn().Err(err).Msg("failed to execute keyboard macro")
 			return last, err
 		}
 
+		// notify the device that the keyboard state is being cleared
+		if isClearKeyStep(step) {
+			gadget.UpdateKeysDown(0, keyboardClearStateKeys)
+		}
+
 		// Use context-aware sleep that can be cancelled
 		select {
 		case <-time.After(delay):
 			// Sleep completed normally
 		case <-ctx.Done():
-			logger.Debug().Int("step", i).Msg("Keyboard report multi cancelled during sleep")
+			// make sure keyboard state is reset
+			_, err := rpcKeyboardReport(0, keyboardClearStateKeys)
+			if err != nil {
+				logger.Warn().Err(err).Msg("failed to reset keyboard state")
+			}
+			gadget.UpdateKeysDown(0, keyboardClearStateKeys)
+
+			logger.Debug().Int("step", i).Msg("Keyboard macro cancelled during sleep")
 			return last, ctx.Err()
 		}
 	}
@@ -1147,8 +1164,6 @@ var rpcHandlers = map[string]RPCHandler{
 	"setNetworkSettings":     {Func: rpcSetNetworkSettings, Params: []string{"settings"}},
 	"renewDHCPLease":         {Func: rpcRenewDHCPLease},
 	"keyboardReport":         {Func: rpcKeyboardReport, Params: []string{"modifier", "keys"}},
-	// "keyboardReportMulti":       {Func: rpcKeyboardReportMultiWrapper, Params: []string{"macro"}},
-	// "cancelKeyboardReportMulti": {Func: rpcCancelKeyboardReportMulti},
 	"getKeyboardLedState":    {Func: rpcGetKeyboardLedState},
 	"keypressReport":         {Func: rpcKeypressReport, Params: []string{"key", "press"}},
 	"getKeyDownState":        {Func: rpcGetKeysDownState},

ui/src/components/popovers/PasteModal.tsx

@@ -1,4 +1,4 @@
-import { useCallback, useEffect, useRef, useState } from "react";
+import { useCallback, useEffect, useMemo, useRef, useState } from "react";
 import { LuCornerDownLeft } from "react-icons/lu";
 import { ExclamationCircleIcon } from "@heroicons/react/16/solid";
 import { useClose } from "@headlessui/react";
@@ -12,6 +12,7 @@ import { useHidStore, useSettingsStore, useUiStore } from "@/hooks/stores";
 import useKeyboard from "@/hooks/useKeyboard";
 import useKeyboardLayout from "@/hooks/useKeyboardLayout";
 import notifications from "@/notifications";
+import { InputFieldWithLabel } from "@components/InputField";
 
 export default function PasteModal() {
   const TextAreaRef = useRef<HTMLTextAreaElement>(null);
@@ -22,6 +23,13 @@ export default function PasteModal() {
   const { executeMacro, cancelExecuteMacro } = useKeyboard();
 
   const [invalidChars, setInvalidChars] = useState<string[]>([]);
+  const [delayValue, setDelayValue] = useState(100);
+  const delay = useMemo(() => {
+    if (delayValue < 50 || delayValue > 65534) {
+      return 100;
+    }
+    return delayValue;
+  }, [delayValue]);
   const close = useClose();
 
   const { setKeyboardLayout } = useSettingsStore();
@@ -41,9 +49,6 @@ export default function PasteModal() {
   }, [setDisableVideoFocusTrap, cancelExecuteMacro]);
 
   const onConfirmPaste = useCallback(async () => {
-    // setPasteModeEnabled(false);
-    // setDisableVideoFocusTrap(false);
-
     if (!TextAreaRef.current || !selectedKeyboard) return;
 
     const text = TextAreaRef.current.value;
@@ -71,7 +76,7 @@ export default function PasteModal() {
           macroSteps.push({
             keys: [String(accentKey.key)],
             modifiers: accentModifiers.length > 0 ? accentModifiers : null,
-            delay: 100,
+            delay,
           });
         }
 
@@ -83,12 +88,12 @@ export default function PasteModal() {
         macroSteps.push({
           keys: [String(key)],
           modifiers: modifiers.length > 0 ? modifiers : null,
-          delay: 100,
+          delay
         });
 
         // if what was requested was a dead key, we need to send an unmodified space to emit
         // just the accent character
-        if (deadKey) macroSteps.push({ keys: ["Space"], modifiers: null, delay: 100 });
+        if (deadKey) macroSteps.push({ keys: ["Space"], modifiers: null, delay });
       }
 
       if (macroSteps.length > 0) {
@@ -98,7 +103,7 @@ export default function PasteModal() {
       console.error("Failed to paste text:", error);
       notifications.error("Failed to paste text");
     }
-  }, [selectedKeyboard, executeMacro]);
+  }, [selectedKeyboard, executeMacro, delay]);
 
   useEffect(() => {
     if (TextAreaRef.current) {
@@ -171,6 +176,27 @@ export default function PasteModal() {
                     )}
                   </div>
                 </div>
+                <div className="text-xs text-slate-600 dark:text-slate-400">
+                  <InputFieldWithLabel
+                    type="number"
+                    label="Delay between keys"
+                    placeholder="Delay between keys"
+                    min={50}
+                    max={65534}
+                    value={delayValue}
+                    onChange={e => {
+                      setDelayValue(parseInt(e.target.value, 10));
+                    }}
+                  />
+                  {delayValue < 50 || delayValue > 65534 && (
+                    <div className="mt-2 flex items-center gap-x-2">
+                      <ExclamationCircleIcon className="h-4 w-4 text-red-500 dark:text-red-400" />
+                      <span className="text-xs text-red-500 dark:text-red-400">
+                        Delay must be between 50 and 65534
+                      </span>
+                    </div>
+                  )}
+                </div>
                 <div className="space-y-4">
                   <p className="text-xs text-slate-600 dark:text-slate-400">
                     Sending text using keyboard layout: {selectedKeyboard.isoCode}-

ui/src/hooks/hidRpc.ts

@@ -8,8 +8,10 @@ export const HID_RPC_MESSAGE_TYPES = {
     KeypressReport: 0x05,
     MouseReport: 0x06,
     KeyboardMacroReport: 0x07,
+    CancelKeyboardMacroReport: 0x08,
     KeyboardLedState: 0x32,
     KeysDownState: 0x33,
+    KeyboardMacroStateReport: 0x34,
 }
 
 export type HidRpcMessageType = typeof HID_RPC_MESSAGE_TYPES[keyof typeof HID_RPC_MESSAGE_TYPES];
@@ -211,34 +213,39 @@ export class KeyboardReportMessage extends RpcMessage {
     }
 }
 
-export interface KeyboardMacro extends KeysDownState {
+export interface KeyboardMacroStep extends KeysDownState {
     delay: number;
 }
 
 export class KeyboardMacroReportMessage extends RpcMessage {
     isPaste: boolean;
     length: number;
-    macro: KeyboardMacro[];
+    steps: KeyboardMacroStep[];
 
     KEYS_LENGTH = 6;
 
-    constructor(isPaste: boolean, length: number, macro: KeyboardMacro[]) {
+    constructor(isPaste: boolean, length: number, steps: KeyboardMacroStep[]) {
         super(HID_RPC_MESSAGE_TYPES.KeyboardMacroReport);
         this.isPaste = isPaste;
         this.length = length;
-        this.macro = macro;
+        this.steps = steps;
     }
 
     marshal(): Uint8Array {
-        const dataHeader = new Uint8Array([
+        // validate if length is correct
+        if (this.length !== this.steps.length) {
+            throw new Error(`Length ${this.length} is not equal to the number of steps ${this.steps.length}`);
+        }
+
+        const data = new Uint8Array(this.length * 9 + 6);
+        data.set(new Uint8Array([
             this.messageType,
             this.isPaste ? 1 : 0,
             ...fromUint32toUint8(this.length),
-        ]);
+        ]), 0);
 
-        let dataBody = new Uint8Array();
+        for (let i = 0; i < this.length; i++) {
-
+            const step = this.steps[i];
-        for (const step of this.macro) {
             if (!withinUint8Range(step.modifier)) {
                 throw new Error(`Modifier ${step.modifier} is not within the uint8 range`);
             }
@@ -262,10 +269,40 @@ export class KeyboardMacroReportMessage extends RpcMessage {
                 ...keys,
                 ...fromUint16toUint8(step.delay),
             ]);
+            const offset = 6 + i * 9;
 
-            dataBody = new Uint8Array([...dataBody, ...macroBinary]);
+            
+            data.set(macroBinary, offset);
         }
-        return new Uint8Array([...dataHeader, ...dataBody]);
+
+        return data;
+    }
+}
+
+export class KeyboardMacroStateReportMessage extends RpcMessage {
+    state: boolean;
+    isPaste: boolean;
+
+    constructor(state: boolean, isPaste: boolean) {
+        super(HID_RPC_MESSAGE_TYPES.KeyboardMacroStateReport);
+        this.state = state;
+        this.isPaste = isPaste;
+    }
+
+    marshal(): Uint8Array {
+        return new Uint8Array([
+            this.messageType,
+            this.state ? 1 : 0,
+            this.isPaste ? 1 : 0,
+        ]);
+    }
+
+    public static unmarshal(data: Uint8Array): KeyboardMacroStateReportMessage | undefined {
+        if (data.length < 1) {
+            throw new Error(`Invalid keyboard macro state report message length: ${data.length}`);
+        }
+
+        return new KeyboardMacroStateReportMessage(data[0] === 1, data[1] === 1);
     }
 }
 
@@ -339,6 +376,17 @@ export class PointerReportMessage extends RpcMessage {
     }
 }
 
+export class CancelKeyboardMacroReportMessage extends RpcMessage {
+
+    constructor() {
+        super(HID_RPC_MESSAGE_TYPES.CancelKeyboardMacroReport);
+    }
+
+    marshal(): Uint8Array {
+        return new Uint8Array([this.messageType]);
+    }
+}
+
 export class MouseReportMessage extends RpcMessage {
     dx: number;
     dy: number;
@@ -367,6 +415,9 @@ export const messageRegistry = {
     [HID_RPC_MESSAGE_TYPES.KeyboardLedState]: KeyboardLedStateMessage,
     [HID_RPC_MESSAGE_TYPES.KeyboardReport]: KeyboardReportMessage,
     [HID_RPC_MESSAGE_TYPES.KeypressReport]: KeypressReportMessage,
+    [HID_RPC_MESSAGE_TYPES.KeyboardMacroReport]: KeyboardMacroReportMessage,
+    [HID_RPC_MESSAGE_TYPES.CancelKeyboardMacroReport]: CancelKeyboardMacroReportMessage,
+    [HID_RPC_MESSAGE_TYPES.KeyboardMacroStateReport]: KeyboardMacroStateReportMessage,
 }
 
 export const unmarshalHidRpcMessage = (data: Uint8Array): RpcMessage | undefined => {

ui/src/hooks/useHidRpc.ts

@@ -3,9 +3,10 @@ import { useCallback, useEffect, useMemo } from "react";
 import { useRTCStore } from "@/hooks/stores";
 
 import {
+  CancelKeyboardMacroReportMessage,
   HID_RPC_VERSION,
   HandshakeMessage,
-  KeyboardMacro,
+  KeyboardMacroStep,
   KeyboardMacroReportMessage,
   KeyboardReportMessage,
   KeypressReportMessage,
@@ -71,10 +72,16 @@ export function useHidRpc(onHidRpcMessage?: (payload: RpcMessage) => void) {
   );
 
   const reportKeyboardMacroEvent = useCallback(
-    (macro: KeyboardMacro[]) => {
+    (macro: KeyboardMacroStep[]) => {
       const d = new KeyboardMacroReportMessage(false, macro.length, macro);
       sendMessage(d);
-      console.log("Sent keyboard macro report", d, d.marshal());
+    },
+    [sendMessage],
+  );
+
+  const cancelOngoingKeyboardMacro = useCallback(
+    () => {
+      sendMessage(new CancelKeyboardMacroReportMessage());
     },
     [sendMessage],
   );
@@ -155,6 +162,7 @@ export function useHidRpc(onHidRpcMessage?: (payload: RpcMessage) => void) {
     reportAbsMouseEvent,
     reportRelMouseEvent,
     reportKeyboardMacroEvent,
+    cancelOngoingKeyboardMacro,
     rpcHidProtocolVersion,
     rpcHidReady,
     rpcHidStatus,

ui/src/hooks/useKeyboard.ts

@@ -9,13 +9,13 @@ import {
 } from "@/hooks/stores";
 import { JsonRpcResponse, useJsonRpc } from "@/hooks/useJsonRpc";
 import { useHidRpc } from "@/hooks/useHidRpc";
-import { KeyboardLedStateMessage, KeyboardMacro, KeysDownStateMessage } from "@/hooks/hidRpc";
+import { KeyboardLedStateMessage, KeyboardMacroStateReportMessage, KeyboardMacroStep, KeysDownStateMessage } from "@/hooks/hidRpc";
 import { hidKeyToModifierMask, keys, modifiers } from "@/keyboardMappings";
 
 export default function useKeyboard() {
   const { send } = useJsonRpc();
   const { rpcDataChannel } = useRTCStore();
-  const { keysDownState, setKeysDownState, setKeyboardLedState } = useHidStore();
+  const { keysDownState, setKeysDownState, setKeyboardLedState, setPasteModeEnabled } = useHidStore();
 
   // INTRODUCTION: The earlier version of the JetKVM device shipped with all keyboard state
   // being tracked on the browser/client-side. When adding the keyPressReport API to the
@@ -33,6 +33,7 @@ export default function useKeyboard() {
     reportKeyboardEvent: sendKeyboardEventHidRpc,
     reportKeypressEvent: sendKeypressEventHidRpc,
     reportKeyboardMacroEvent: sendKeyboardMacroEventHidRpc,
+    cancelOngoingKeyboardMacro: cancelOngoingKeyboardMacroHidRpc,
     rpcHidReady,
   } = useHidRpc(message => {
     switch (message.constructor) {
@@ -42,6 +43,10 @@ export default function useKeyboard() {
       case KeyboardLedStateMessage:
         setKeyboardLedState((message as KeyboardLedStateMessage).keyboardLedState);
         break;
+      case KeyboardMacroStateReportMessage:
+        if (!(message as KeyboardMacroStateReportMessage).isPaste) break;
+        setPasteModeEnabled((message as KeyboardMacroStateReportMessage).state);
+        break;  
       default:
         break;
     }
@@ -101,7 +106,7 @@ export default function useKeyboard() {
   const executeMacro = async (
     steps: { keys: string[] | null; modifiers: string[] | null; delay: number }[],
   ) => {
-    const macro: KeyboardMacro[] = [];
+    const macro: KeyboardMacroStep[] = [];
 
     for (const [_, step] of steps.entries()) {
       const keyValues = (step.keys || []).map(key => keys[key]).filter(Boolean);
@@ -111,8 +116,8 @@ export default function useKeyboard() {
 
       // If the step has keys and/or modifiers, press them and hold for the delay
       if (keyValues.length > 0 || modifierMask > 0) {
-        macro.push({ keys: keyValues, modifier: modifierMask, delay: 50 });
+        macro.push({ keys: keyValues, modifier: modifierMask, delay: 20 });
-        macro.push({ ...MACRO_RESET_KEYBOARD_STATE, delay: 200 });
+        macro.push({ ...MACRO_RESET_KEYBOARD_STATE, delay: step.delay || 100 });
       }
     }
 
@@ -120,12 +125,9 @@ export default function useKeyboard() {
   };
 
   const cancelExecuteMacro = useCallback(async () => {
-    send("cancelKeyboardReportMulti", {}, (resp: JsonRpcResponse) => {
+    if (!rpcHidReady) return;
-      if ("error" in resp) {
+    cancelOngoingKeyboardMacroHidRpc();
-        console.error(`Failed to cancel keyboard report multi`, resp.error);
+  }, [rpcHidReady, cancelOngoingKeyboardMacroHidRpc]);
-      }
-    });
-  }, [send]);
 
   // handleKeyPress is used to handle a key press or release event.
   // This function handle both key press and key release events.

ui/src/routes/devices.$id.tsx

@@ -580,7 +580,7 @@ export default function KvmIdRoute() {
   const { setNetworkState} = useNetworkStateStore();
   const { setHdmiState } = useVideoStore();
   const { 
-    keyboardLedState,  setKeyboardLedState, setPasteModeEnabled,
+    keyboardLedState,  setKeyboardLedState,
     keysDownState, setKeysDownState, setUsbState,
   } = useHidStore();
 
@@ -598,12 +598,6 @@ export default function KvmIdRoute() {
       setUsbState(usbState);
     }
 
-    if (resp.method === "keyboardReportMultiState") {
-      const reportMultiState = resp.params as unknown as boolean;
-      console.debug("Setting keyboard report multi state", reportMultiState);
-      setPasteModeEnabled(reportMultiState);
-    }
-
     if (resp.method === "videoInputState") {
       const hdmiState = resp.params as Parameters<VideoState["setHdmiState"]>[0];
       console.debug("Setting HDMI state", hdmiState);

web.go

@@ -200,7 +200,7 @@ func handleWebRTCSession(c *gin.Context) {
 	}
 
 	// Cancel any ongoing keyboard report multi when session changes
-	cancelKeyboardReportMulti()
+	cancelKeyboardMacro()
 
 	currentSession = session
 	c.JSON(http.StatusOK, gin.H{"sd": sd})

webrtc.go

@@ -267,7 +267,7 @@ func newSession(config SessionConfig) (*Session, error) {
 			scopedLogger.Debug().Msg("ICE Connection State is closed, unmounting virtual media")
 			if session == currentSession {
 				// Cancel any ongoing keyboard report multi when session closes
-				cancelKeyboardReportMulti()
+				cancelKeyboardMacro()
 				currentSession = nil
 			}
 			// Stop RPC processor