fix(terminal): forward Cmd+C to Kitty when there is no xterm selection

macOS copy defaults to Cmd+C. With no terminal selection, the shortcut
handler used to consume the chord as an empty clipboard write, so nested
TUIs that expect Kitty Super+C (e.g. Herdr) never received the key.

Pass plain Meta+C through the same no-selection path as Ctrl+C, while
keeping other unbound copy chords as a safe no-op (#1461).

Closes #2728

Co-authored-by: 陈大猫 <binaricat@users.noreply.github.com>

components/terminal/runtime/createXTermRuntime.ts

@@ -1476,8 +1476,8 @@ export const createXTermRuntime = (ctx: CreateXTermRuntimeContext): XTermRuntime
           ) {
             return true;
           }
-          // When copy is bound specifically to Ctrl+C and there is no text
-          // selected, pass the event through so xterm can send SIGINT.
+          // No xterm selection: pass Ctrl+C through for SIGINT, and Cmd+C for
+          // Kitty Super+C (nested TUIs). Other copy chords stay a safe no-op.
           const shouldForwardCopyToTerminal =
             shouldPassThroughCopyShortcut(action, term.hasSelection(), e);
           if (shouldForwardCopyToTerminal && !kittySequenceForKeyDown) return true;

components/terminal/runtime/terminalCopyShortcut.test.ts

@@ -3,6 +3,7 @@ import test from "node:test";
 
 import {
   isPlainCtrlCInterruptChord,
+  isPlainMetaCCopyChord,
   shouldPassThroughCopyShortcut,
 } from "./terminalCopyShortcut.ts";
 
@@ -27,10 +28,20 @@ test("plain Ctrl+C copy with no selection passes through for SIGINT", () => {
   assert.equal(shouldPassThroughCopyShortcut("copy", false, event), true);
 });
 
-test("copy shortcut does not pass through when text is selected", () => {
-  const event = keyboardEvent("c", "KeyC", { ctrlKey: true });
+test("plain Cmd+C copy with no selection passes through for Kitty Super+C", () => {
+  const event = keyboardEvent("c", "KeyC", { metaKey: true });
 
-  assert.equal(shouldPassThroughCopyShortcut("copy", true, event), false);
+  assert.equal(isPlainMetaCCopyChord(event), true);
+  assert.equal(isPlainCtrlCInterruptChord(event), false);
+  assert.equal(shouldPassThroughCopyShortcut("copy", false, event), true);
+});
+
+test("copy shortcut does not pass through when text is selected", () => {
+  const ctrlC = keyboardEvent("c", "KeyC", { ctrlKey: true });
+  const cmdC = keyboardEvent("c", "KeyC", { metaKey: true });
+
+  assert.equal(shouldPassThroughCopyShortcut("copy", true, ctrlC), false);
+  assert.equal(shouldPassThroughCopyShortcut("copy", true, cmdC), false);
 });
 
 test("copy shortcut does not pass through for shifted or alternate chords", () => {
@@ -38,14 +49,26 @@ test("copy shortcut does not pass through for shifted or alternate chords", () =
     shouldPassThroughCopyShortcut("copy", false, keyboardEvent("C", "KeyC", { ctrlKey: true, shiftKey: true })),
     false,
   );
+  assert.equal(
+    shouldPassThroughCopyShortcut("copy", false, keyboardEvent("C", "KeyC", { metaKey: true, shiftKey: true })),
+    false,
+  );
   assert.equal(
     shouldPassThroughCopyShortcut("copy", false, keyboardEvent("l", "KeyL", { ctrlKey: true })),
     false,
   );
+  assert.equal(
+    shouldPassThroughCopyShortcut("copy", false, keyboardEvent("c", "KeyC", { metaKey: true, ctrlKey: true })),
+    false,
+  );
   assert.equal(
     shouldPassThroughCopyShortcut("paste", false, keyboardEvent("c", "KeyC", { ctrlKey: true })),
     false,
   );
+  assert.equal(
+    shouldPassThroughCopyShortcut("paste", false, keyboardEvent("c", "KeyC", { metaKey: true })),
+    false,
+  );
 });
 
 test("plain Ctrl+C copy passthrough follows the physical C key on non-Latin layouts", () => {
@@ -54,3 +77,10 @@ test("plain Ctrl+C copy passthrough follows the physical C key on non-Latin layo
   assert.equal(isPlainCtrlCInterruptChord(event), true);
   assert.equal(shouldPassThroughCopyShortcut("copy", false, event), true);
 });
+
+test("plain Cmd+C copy passthrough follows the physical C key on non-Latin layouts", () => {
+  const event = keyboardEvent("\u0441", "KeyC", { metaKey: true });
+
+  assert.equal(isPlainMetaCCopyChord(event), true);
+  assert.equal(shouldPassThroughCopyShortcut("copy", false, event), true);
+});

components/terminal/runtime/terminalCopyShortcut.ts

@@ -3,18 +3,43 @@ type CopyShortcutKeyEvent = Pick<
   "key" | "code" | "ctrlKey" | "shiftKey" | "altKey" | "metaKey"
 >;
 
+function isPhysicalCKey(e: CopyShortcutKeyEvent): boolean {
+  return e.key.toLowerCase() === "c" || e.code === "KeyC";
+}
+
 export function isPlainCtrlCInterruptChord(e: CopyShortcutKeyEvent): boolean {
   return e.ctrlKey
     && !e.shiftKey
     && !e.altKey
     && !e.metaKey
-    && (e.key.toLowerCase() === "c" || e.code === "KeyC");
+    && isPhysicalCKey(e);
 }
 
+/** macOS Cmd+C / Super+C — forward when there is no xterm selection. */
+export function isPlainMetaCCopyChord(e: CopyShortcutKeyEvent): boolean {
+  return e.metaKey
+    && !e.ctrlKey
+    && !e.shiftKey
+    && !e.altKey
+    && isPhysicalCKey(e);
+}
+
+/**
+ * When copy matches with no xterm selection, pass the chord through instead of
+ * consuming an empty clipboard write.
+ *
+ * - Ctrl+C → SIGINT (or Kitty Ctrl+C)
+ * - Cmd+C → Kitty Super+C for nested TUIs (e.g. Herdr)
+ *
+ * Other no-selection copy bindings stay consumed as a safe no-op so keys like
+ * F5 / Ctrl+L are not forwarded to the remote (#1461).
+ */
 export function shouldPassThroughCopyShortcut(
   action: string,
   hasSelection: boolean,
   e: CopyShortcutKeyEvent,
 ): boolean {
-  return action === "copy" && !hasSelection && isPlainCtrlCInterruptChord(e);
+  return action === "copy"
+    && !hasSelection
+    && (isPlainCtrlCInterruptChord(e) || isPlainMetaCCopyChord(e));
 }