Skip to content

Add "Send Ctrl-F to Terminal" passthrough action (force-stop Claude Code agents) (#4993)#5011

Open
austinywang wants to merge 2 commits into
mainfrom
issue-4993-ctrl-f-passthrough
Open

Add "Send Ctrl-F to Terminal" passthrough action (force-stop Claude Code agents) (#4993)#5011
austinywang wants to merge 2 commits into
mainfrom
issue-4993-ctrl-f-passthrough

Conversation

@austinywang
Copy link
Copy Markdown
Contributor

@austinywang austinywang commented May 30, 2026

Fixes #4993.

Problem

Inside a cmux-managed Claude Code (CC) session, force-stopping a hung background agent is only exposed by CC as a TUI keybinding — its watchdog instructs "press Ctrl-F twice." Because that chord is read off the raw tty, it inherits every keystroke-capture layer between the window and the PTY, and there is no non-keyboard way to deliver it. /clear does not help (CC preserves background agents by design), so a hung agent can't be cleared short of killing the session.

The maintainer comment on the issue states the durable framing: "any ctrl-chord CC reads off the raw tty is one keystroke-capture handler away from being swallowed … the durable fix is a non-keyboard stop path."

Investigation (what actually swallows plain Ctrl-F today)

Tracing cmux's key-routing path on current main with default settings, plain Ctrl-F is not captured by cmux and already reaches the PTY:

  • Not bound to any cmux action — find=⌘F, toggleFullScreen=⌘⌃F, switchRightSidebarToFind=⌃2.
  • Not a Ghostty default keybind, not a menu key-equivalent.
  • The window performKeyEquivalent swizzle returns false for non-⌘ chords, so the event flows to GhosttyTerminalView.keyDown's control fast path and is encoded to the PTY as ^F (the only thing that intercepts ^F is keyboard copy-mode, which the user must explicitly toggle on).

So the literal "cmux grabs Ctrl-F" does not reproduce in code. The real, durable gap — and what this PR delivers — is a non-keyboard affordance to deliver the chord, so force-stop works regardless of how fragile keystroke routing is for any given TUI chord.

Fix — one shared passthrough action, wired through every surface

A single shared model path, TabManager.sendCtrlFToFocusedTerminal(), delivers a faithfully Ghostty-encoded Ctrl-F to the focused terminal's PTY via the existing named-key path (sendNamedKey("ctrl-f")), so it respects the surface's current keyboard-encoding mode and matches a real keystroke. It bypasses cmux's shortcut/menu/responder layers entirely. Invoke twice to force-stop.

Entrypoints (per the repo's shared-behavior policy):

  • Customizable shortcut — new KeyboardShortcutSettings.Action.sendCtrlFToTerminal, editable in Settings, unbound by default (binding plain Ctrl-F would be self-referential; users opt in).
  • Command palettepalette.terminalSendCtrlF, searchable by "force stop / agent / claude / ctrl f / hung".
  • Menu — Find menu item, disabled when no terminal is focused.
  • CLI / socketsend_key ctrl-f (already worked via the generic parser; now an explicit named case + help text).
  • cmux.jsonshortcuts.bindings.sendCtrlFToTerminal (auto-derived from the action).
  • Docs — keyboard-shortcuts + configuration pages derive from the single web/data/cmux-shortcuts.ts source.
  • Localization — en + ja strings added.

Altitude (why Ctrl-F specifically in the GUI, not an arbitrary-key picker)

The general raw-key passthrough already exists on the CLI (send_key <key>). A key-picker is the wrong ergonomics for a quick GUI force-stop, so the GUI surfaces expose the concrete Ctrl-F chord (the issue's documented need) while the socket command stays general. This eliminates the class — a structured action has no keystroke left to intercept — without special-casing a keycode in the routing layer.

Tests

Behavioral guards (added to the already-wired TerminalAndGhosttyTests):

  • testSendNamedKeyRecognizesCtrlFForceStopChordctrl-f/ctrl+f resolve to a recognized, deliverable chord (.surfaceUnavailable on a closed surface vs .unknownKey for garbage), locking the encoding the affordance depends on.
  • testNamedKeySendResultAcceptedReflectsDelivery — the new NamedKeySendResult.accepted maps delivery vs failure correctly.

On red-first: a red-first regression test does not apply here. The byte-level chord encoding already worked generically on main; the defect was the absence of a non-keyboard affordance, which is GUI/menu/palette wiring exercised only at integration level, not a unit-reproducible capture bug. Stated plainly rather than faking a red/green.

🤖 Generated with Claude Code


View with Codesmith Autofix with Codesmith
Need help on this PR? Tag @codesmith with what you need. Autofix is disabled.


Note

Low Risk
UI and input-forwarding only; no auth, persistence, or security-sensitive paths; default shortcut is unbound and delivery is gated on a focused terminal.

Overview
Adds a Send Ctrl-F to Terminal action so users can deliver a Ghostty-encoded ^F to the focused PTY without relying on keyboard routing—aimed at TUIs (e.g. Claude Code) that require Ctrl-F twice to force-stop hung background agents.

TabManager.sendCtrlFToFocusedTerminal() calls sendNamedKey("ctrl-f"), refreshes the surface on success, and reports delivery via new NamedKeySendResult.accepted. The named-key parser now maps ctrl-f / ctrl+f.

The action is wired through Settings (sendCtrlFToTerminal, unbound by default), command palette, Find menu (with focus restore), AppDelegate shortcut handling (event consumed only when delivery succeeds), socket help for send_key ctrl-f, web shortcut docs, and localization. Unit tests lock ctrl-f recognition and the accepted flag.

Reviewed by Cursor Bugbot for commit fb798df. Bugbot is set up for automated code reviews on this repo. Configure here.


Summary by cubic

Adds a non-keyboard action to send Ctrl‑F to the focused terminal, giving a reliable way to force‑stop hung Claude Code agents even when keystrokes are intercepted. Invoke it twice to trigger the stop.

  • New Features
    • Adds TabManager.sendCtrlFToFocusedTerminal() which forwards a Ghostty‑encoded Ctrl‑F via sendNamedKey("ctrl-f"); extends the named‑key map to recognize ctrl-f/ctrl+f and adds NamedKeySendResult.accepted to report delivery.
    • Exposed via: command palette (“Send Ctrl‑F to Terminal”), Find menu item, configurable shortcut (sendCtrlFToTerminal, unbound by default), and CLI/socket send_key ctrl-f (help text updated).
    • Behavior: only runs when a terminal is focused, respects current keyboard encoding, and beeps on failure.
    • Localization: adds strings for all catalog locales (en/ja translated; others seeded with English for review).

Written for commit fb798df. Summary will update on new commits.

Review in cubic

Summary by CodeRabbit

  • New Features

    • Added a "Send Ctrl‑F to Terminal" command accessible from the Find menu, command palette, and shortcut settings; forwards Ctrl‑F to the focused terminal (unbound by default) and signals failure with a system beep.
  • Documentation

    • Added localized strings (English, Japanese translated; other locales marked for review) and updated help text/descriptions across UI and web shortcut listing.
  • Tests

    • Added regression tests for Ctrl‑F delivery and delivery-state reporting.

Review Change Stack

Issue #4993: inside a cmux-managed Claude Code session, CC only exposes
force-stop as a TUI keybinding ("press Ctrl-F twice"). The maintainer
framing is the durable one: any ctrl-chord a TUI reads off the raw tty is
one keystroke-capture handler away from being swallowed, so the fix is a
non-keyboard stop path rather than patching one binding.

This adds a single shared action that delivers a faithfully Ghostty-encoded
Ctrl-F to the focused terminal's PTY, bypassing cmux's shortcut/menu/
responder layers entirely. Encoding goes through the existing named-key
path (`sendNamedKey("ctrl-f")`) so it respects the surface's current
keyboard mode, matching a real keystroke. Invoke it twice to force-stop.

Altitude: the general raw-key passthrough already exists on the CLI
(`send_key <key>`); a key picker is wrong ergonomics for a quick GUI
force-stop, so the GUI surfaces expose the concrete Ctrl-F chord while the
socket command stays general. Default shortcut is unbound (binding plain
Ctrl-F would be self-referential); users opt in via Settings.

Shared model path: TabManager.sendCtrlFToFocusedTerminal(), wired to every
entrypoint — customizable KeyboardShortcutSettings action, command palette,
Find menu item, cmux.json shortcuts.bindings (auto), and `send_key ctrl-f`
(now an explicit named case + help text). Docs derive from the single
cmux-shortcuts.ts source; strings localized en/ja.

Tests: behavioral guards that the ctrl-f chord stays recognized/deliverable
(TerminalSurface.sendNamedKey) and that NamedKeySendResult.accepted maps
delivery correctly. A red-first regression test does not apply: the byte
encoding already worked generically; the defect was the missing non-keyboard
affordance, which is GUI/menu/palette wiring exercised at integration level.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>
@vercel
Copy link
Copy Markdown

vercel Bot commented May 30, 2026

The latest updates on your projects. Learn more about Vercel for GitHub.

Project Deployment Actions Updated (UTC)
cmux Ready Ready Preview, Comment May 30, 2026 11:33pm
cmux-staging Building Building Preview, Comment May 30, 2026 11:33pm

@coderabbitai
Copy link
Copy Markdown

coderabbitai Bot commented May 30, 2026

📝 Walkthrough

Walkthrough

Adds an opt-in shortcut and UI (menu, command palette, app dispatcher) to forward a Ctrl‑F named-key to the focused terminal, implements terminal-side mapping and delivery semantics, updates keyboard shortcut settings, adds tests, and inserts localization and web shortcut metadata.

Changes

Terminal Ctrl+F Forwarding

Layer / File(s) Summary
Terminal Ctrl+F support and accepted delivery semantics
Sources/GhosttyTerminalView.swift, cmuxTests/TerminalAndGhosttyTests.swift
Maps ctrl-f / ctrl+f to a Ctrl-modified F key event and adds TerminalSurface.NamedKeySendResult.accepted to indicate delivered/queued vs dropped; tests validate chord recognition and accepted semantics.
Tab manager Ctrl-F forwarding method
Sources/TabManager.swift
TabManager.sendCtrlFToFocusedTerminal() forwards the ctrl-f named key to the focused terminal, triggers a refresh when sent, logs in DEBUG builds, and returns whether the chord was accepted.
Keyboard shortcut action registration
Sources/KeyboardShortcutSettings.swift, Sources/KeyboardShortcutContext.swift
Adds KeyboardShortcutSettings.Action.sendCtrlFToTerminal with a localized label, default .unbound, and classifies its context as .nonBrowserPanel.
App dispatcher, command palette, and menu wiring
Sources/AppDelegate.swift, Sources/ContentView+RightSidebarCommandPalette.swift, Sources/ContentView.swift, Sources/cmuxApp.swift
App dispatcher handles .sendCtrlFToTerminal; command-palette adds palette.terminalSendCtrlF visible only for terminal focus and registers a handler that forwards Ctrl‑F and beeps on failure; Find menu gets a "Send Ctrl-F to Terminal" item (disabled when no terminal selected).
Localization and documentation
Resources/Localizable.xcstrings, Sources/TerminalController.swift, web/data/cmux-shortcuts.ts
Adds three localization keys for the command/menu/shortcut labels (en/ja translated, others flagged needs_review), updates send_key help text to include ctrl-f, and adds sendCtrlFToTerminal to web shortcut metadata (unbound by default, with force-stop note).

Estimated code review effort

🎯 3 (Moderate) | ⏱️ ~20 minutes

Possibly related PRs

  • manaflow-ai/cmux#4193: Modifies NamedKeySendResult and sendNamedKey plumbing that this PR leverages for ctrl-f delivery state inspection and forwarding.
  • manaflow-ai/cmux#4333: Related terminal shortcut/dispatch changes and focus routing that overlap with this PR's dispatcher and TabManager edits.

Suggested reviewers

  • jesstelford

Poem

🐰 I taped a key to help the code,
Ctrl‑F hops through the terminal mode.
Two taps to stop an agent's spree,
Now Claude can rest — thanks to me! 🥕

🚥 Pre-merge checks | ✅ 17 | ❌ 1

❌ Failed checks (1 warning)

Check name Status Explanation Resolution
Docstring Coverage ⚠️ Warning Docstring coverage is 7.69% which is insufficient. The required threshold is 80.00%. Write docstrings for the functions missing them to satisfy the coverage threshold.
✅ Passed checks (17 passed)
Check name Status Explanation
Title check ✅ Passed The title clearly and specifically describes the main change: adding a "Send Ctrl-F to Terminal" passthrough action with context about its purpose (force-stopping Claude Code agents). It is directly related to the primary objective of the changeset.
Linked Issues check ✅ Passed The PR fully addresses the objectives from #4993 by implementing a non-keyboard affordance to deliver Ctrl-F to the focused terminal. All requirements are met: the affordance works through multiple entrypoints (command palette, menu, shortcut, CLI), respects terminal encoding, and invokes twice to force-stop hung Claude Code agents.
Out of Scope Changes check ✅ Passed All changes are in scope and directly support the core objective of enabling non-keyboard Ctrl-F delivery to the terminal. Modifications span terminal handling, UI wiring, localization, documentation, and tests—all necessary components of the feature and consistent with the PR's stated scope.
Cmux Swift Actor Isolation ✅ Passed All new Swift production code follows actor isolation rules: new methods are in @MainActor class, enums don't require isolation, SwiftUI types follow convention, no shared mutable types introduced.
Cmux Swift Blocking Runtime ✅ Passed No blocking/timing primitives introduced in production code. All changes are non-blocking method calls, enum cases, and test-only DispatchSemaphore scaffolding.
Cmux No Hacky Sleeps ✅ Passed The only TypeScript production change is web/data/cmux-shortcuts.ts, a pure data file with no timing constructs (sleep, setTimeout, polling, etc.) or race condition workarounds.
Cmux Algorithmic Complexity ✅ Passed PR adds only O(1) operations: direct property lookups, enum cases, switch statements, and single-panel method calls. No collection scans, rescans, or nested iterations added in hot paths.
Cmux Swift Concurrency ✅ Passed All new sendCtrlF code uses purely synchronous patterns. No background DispatchQueue, fire-and-forget Tasks, new Combine, or completion-handler APIs violating cmux control constraints were introduced.
Cmux Swift @Concurrent ✅ Passed All new Swift functions are synchronous and properly MainActor-isolated. No @concurrent violations detected.
Cmux Swift File And Package Boundaries ✅ Passed All additions <250 lines to large files (TabManager +27 max). No new files or mixed responsibilities. Feature properly distributed across existing app layer with clear separation of concerns.
Cmux Swift Logging ✅ Passed All logging in the PR complies with swift-logging.md rules: debug logs use cmuxDebugLog guarded by #if DEBUG; no print/debugPrint/dump/NSLog in app code; no secrets logged.
Cmux User-Facing Error Privacy ✅ Passed User-facing strings comply with privacy policy. Claude Code references are permitted as it's user-configured in cmux. No credentials, tokens, internal flags, or sensitive details exposed.
Cmux Full Internationalization ✅ Passed All Swift code uses String(localized:defaultValue:); three new xcstrings entries have translations for all 15 existing locales; web/data/cmux-shortcuts.ts follows established en/ja-only pattern.
Cmux Swiftui State Layout ✅ Passed PR introduces no new @Published/@observableobject state, GeometryReader, lazy-list store refs, or render-time mutations. Changes are enum case, method, and UI action handlers without state writes.
Cmux Architecture Rethink ✅ Passed Ctrl-F passthrough via TabManager.sendCtrlFToFocusedTerminal(), single ownership, no timing tricks, no state duplication, clean invariants—satisfies architectural rethink rules.
Cmux Swift Auxiliary Window Close Shortcuts ✅ Passed No new NSWindow, NSPanel, NSWindowController, or SwiftUI Window/WindowGroup objects created. Only adds menu items, shortcuts, command palette entries, and localization strings.
Description check ✅ Passed The PR description comprehensively covers all required sections: problem statement, investigation, fix explanation with implementation details, tests, and checklist completion.

✏️ Tip: You can configure your own custom pre-merge checks in the settings.

✨ Finishing Touches
📝 Generate docstrings
  • Create stacked PR
  • Commit on current branch
🧪 Generate unit tests (beta)
  • Create PR with unit tests
  • Commit unit tests in branch issue-4993-ctrl-f-passthrough

Thanks for using CodeRabbit! It's free for OSS, and your support helps us grow. If you like it, consider giving us a shout-out.

❤️ Share

Comment @coderabbitai help to get the list of available commands and usage tips.

@greptile-apps
Copy link
Copy Markdown
Contributor

greptile-apps Bot commented May 30, 2026

Greptile Summary

This PR adds a "Send Ctrl-F to Terminal" action as a structured, non-keyboard escape hatch to deliver ^F to the focused PTY — primarily so users can force-stop hung Claude Code background agents without relying on fragile keystroke routing.

  • New TabManager.sendCtrlFToFocusedTerminal() calls panel.sendNamedKeyResult(\"ctrl-f\") via the existing named-key path, calls forceRefresh only on .sent (consistent with TerminalController patterns), and returns result.accepted to let callers know if delivery succeeded.
  • Five entrypoints are wired: customizable keyboard shortcut (unbound by default), command palette (palette.terminalSendCtrlF), Find menu (with restoreFindTargetFocus() pre-call), CLI send_key help text, and cmux.json bindings.
  • NamedKeySendResult.accepted and the ctrl-f/ctrl+f named-key mapping are added to GhosttyTerminalView, and all 20 supported locales get needs_review stubs in Localizable.xcstrings matching the existing catalog pattern.

Confidence Score: 5/5

Safe to merge — all changes are additive UI wiring with no mutations to existing state, auth, or persistence paths.

The change adds a new forwarding path for a single control chord. All five entrypoints follow the existing patterns in the codebase exactly — the forceRefresh-on-.sent-only pattern matches TerminalController, the shortcut handler mirrors .attachTextBoxFile, and localization stubs cover every supported locale. No existing behavior is modified.

No files require special attention.

Important Files Changed

Filename Overview
Sources/TabManager.swift Adds sendCtrlFToFocusedTerminal() — correctly guards on selectedTerminalPanel, calls forceRefresh only on .sent (matching TerminalController pattern), and delegates to result.accepted for caller feedback.
Sources/GhosttyTerminalView.swift Adds ctrl-f/ctrl+f named-key mapping and NamedKeySendResult.accepted computed property; both cases follow existing enum patterns.
Sources/cmuxApp.swift Adds Find menu item that calls restoreFindTargetFocus() then sendCtrlFToFocusedTerminal(), disabled when no terminal is selected — consistent with other menu items in this file.
Sources/AppDelegate.swift Shortcut handler follows the identical pattern as .attachTextBoxFile and .focusTextBoxInput: routes to preferredMainWindowContextForShortcutRouting, returns handled.
Resources/Localizable.xcstrings All three new string keys include needs_review stubs for all 20 supported locales — matching the existing catalog pattern.
Sources/KeyboardShortcutSettings.swift Adds sendCtrlFToTerminal action with .unbound default and a clear comment explaining why; label uses String(localized:defaultValue:) correctly.
Sources/ContentView.swift Command palette contribution and registry handler correctly wired for palette.terminalSendCtrlF, beeps on failure, consistent with nearby entries.
cmuxTests/TerminalAndGhosttyTests.swift Two new tests: one verifies ctrl-f/ctrl+f are recognized, the other exhaustively maps all NamedKeySendResult cases to accepted.
web/data/cmux-shortcuts.ts New entry follows the existing LocalizedText (en/ja only) pattern; keyboard-shortcuts page falls back to en for other locales, which is pre-existing behavior.

Flowchart

%%{init: {'theme': 'neutral'}}%%
flowchart TD
    A[User wants to force-stop\nhung TUI agent] --> B{Entry point}
    B --> C[Keyboard Shortcut\nunbound by default]
    B --> D[Command Palette\npalette.terminalSendCtrlF]
    B --> E[Find Menu\nSend Ctrl-F to Terminal]
    B --> F[CLI Socket\nsend_key ctrl-f]
    C --> G[AppDelegate\nmatchConfiguredShortcut]
    D --> H[ContentView registry]
    E --> I[cmuxApp.swift\nrestoreFindTargetFocus]
    F --> J[TerminalController\nsendKey handler]
    G --> K[TabManager\nsendCtrlFToFocusedTerminal]
    H --> K
    I --> K
    J --> L[TerminalPanel\nsendNamedKeyResult ctrl-f]
    K --> M{selectedTerminalPanel?}
    M -- nil --> N[return false / beep]
    M -- panel --> L
    L --> O[TerminalSurface\nsendNamedKey ctrl-f]
    O --> P[pendingKeyEvent\nkVK_ANSI_F + GHOSTTY_MODS_CTRL]
    P --> Q{NamedKeySendResult}
    Q -- .sent --> R[forceRefresh + return true]
    Q -- .queued --> S[return true]
    Q -- failure cases --> N
Loading

Reviews (2): Last reviewed commit: "Localize Ctrl-F passthrough strings for ..." | Re-trigger Greptile

Comment on lines 155872 to 155928
}
}
},
"command.terminalSendCtrlF.title": {
"extractionState": "manual",
"localizations": {
"en": {
"stringUnit": {
"state": "translated",
"value": "Send Ctrl-F to Terminal"
}
},
"ja": {
"stringUnit": {
"state": "translated",
"value": "ターミナルにCtrl-Fを送信"
}
}
}
},
"menu.find.sendCtrlFToTerminal": {
"extractionState": "manual",
"localizations": {
"en": {
"stringUnit": {
"state": "translated",
"value": "Send Ctrl-F to Terminal"
}
},
"ja": {
"stringUnit": {
"state": "translated",
"value": "ターミナルにCtrl-Fを送信"
}
}
}
},
"shortcut.sendCtrlFToTerminal.label": {
"extractionState": "manual",
"localizations": {
"en": {
"stringUnit": {
"state": "translated",
"value": "Send Ctrl-F to Terminal"
}
},
"ja": {
"stringUnit": {
"state": "translated",
"value": "ターミナルにCtrl-Fを送信"
}
}
}
},
"shortcut.attachTextBoxFile.label": {
"extractionState": "manual",
"localizations": {
Copy link
Copy Markdown
Contributor

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

P1 Missing locale entries for 18 locales

The three new string keys (command.terminalSendCtrlF.title, menu.find.sendCtrlFToTerminal, shortcut.sendCtrlFToTerminal.label) only include en and ja localizations. The catalog already supports ar, bs, da, de, es, fr, it, km, ko, nb, pl, pt-BR, ru, th, tr, uk, zh-Hans, and zh-Hant. Every other entry added alongside a new action (e.g. shortcut.attachTextBoxFile.label) carries "state": "needs_review" stubs for every supported locale. Without those stubs, the string catalog is incomplete and users on non-en/non-ja builds will fall back to the defaultValue literal rather than a catalog-managed fallback — bypassing translation pipeline review for all 18 locales.

Rule Used: Flag production user-facing text that is not fully... (source)

Copy link
Copy Markdown
Contributor Author

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

Fixed in fb798df — expanded all three new keys to the full 20-locale catalog set (en + ja translated; the other 18 locales seeded with the English value and state=needs_review, matching the placeholder convention existing untranslated entries use).

— Claude Code

Copy link
Copy Markdown

@coderabbitai coderabbitai Bot left a comment

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

Actionable comments posted: 1

🤖 Prompt for all review comments with AI agents
Verify each finding against current code. Fix only still-valid issues, skip the
rest with a brief reason, keep changes minimal, and validate.

Inline comments:
In `@Sources/ContentView.swift`:
- Around line 7405-7416: The Localizable.xcstrings file only contains
command.terminalSendCtrlF.title for en and ja; add the missing localized entries
for the key "command.terminalSendCtrlF.title" for every locale listed in the app
catalog (ar, bs, da, de, es, fr, it, km, ko, nb, pl, pt-BR, ru, th, tr, uk,
zh-Hans, zh-Hant) so the CommandPaletteCommandContribution with commandId
"palette.terminalSendCtrlF" has a proper title in all supported locales; update
each locale’s Localizable.xcstrings (or corresponding .strings/.xtstrings files)
with the translated string (or fallback copy of English if translation not
available) and ensure the project resource catalog includes those locale files.
🪄 Autofix (Beta)

Fix all unresolved CodeRabbit comments on this PR:

  • Push a commit to this branch (recommended)
  • Create a new PR with the fixes

ℹ️ Review info
⚙️ Run configuration

Configuration used: Path: .coderabbit.yaml

Review profile: ASSERTIVE

Plan: Pro

Run ID: 2991c237-3ca8-463f-9e38-7980a20e01b0

📥 Commits

Reviewing files that changed from the base of the PR and between 239600b and 11b89ef.

📒 Files selected for processing (12)
  • Resources/Localizable.xcstrings
  • Sources/AppDelegate.swift
  • Sources/ContentView+RightSidebarCommandPalette.swift
  • Sources/ContentView.swift
  • Sources/GhosttyTerminalView.swift
  • Sources/KeyboardShortcutContext.swift
  • Sources/KeyboardShortcutSettings.swift
  • Sources/TabManager.swift
  • Sources/TerminalController.swift
  • Sources/cmuxApp.swift
  • cmuxTests/TerminalAndGhosttyTests.swift
  • web/data/cmux-shortcuts.ts

Comment thread Sources/ContentView.swift
CodeRabbit/Greptile flagged that the three new string keys
(command.terminalSendCtrlF.title, menu.find.sendCtrlFToTerminal,
shortcut.sendCtrlFToTerminal.label) only had en/ja while every other entry
in Localizable.xcstrings carries all 20 catalog locales. Expand each to the
full locale set, matching the file convention: en + ja translated, the other
18 locales seeded with the English value and state=needs_review (the same
placeholder pattern existing untranslated entries use).

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>
Copy link
Copy Markdown

@cursor cursor Bot left a comment

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

Cursor Bugbot has reviewed your changes and found 1 potential issue.

Fix All in Cursor

❌ Bugbot Autofix is OFF. To automatically fix reported issues with cloud agents, enable autofix in the Cursor dashboard.

Reviewed by Cursor Bugbot for commit fb798df. Configure here.

case toggleTerminalCopyMode
case focusTextBoxInput
case attachTextBoxFile
case sendCtrlFToTerminal
Copy link
Copy Markdown

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

Settings UI missing shortcut action

Medium Severity

sendCtrlFToTerminal was added to KeyboardShortcutSettings.Action and wired in the app, but not to the mirrored ShortcutAction enum used by the Settings keyboard-shortcuts UI and shortcuts.bindings catalog. Users cannot discover, bind, or reset this shortcut in Settings like adjacent terminal actions (focusTextBoxInput, attachTextBoxFile), despite the PR describing it as customizable.

Fix in Cursor Fix in Web

Reviewed by Cursor Bugbot for commit fb798df. Configure here.

Copy link
Copy Markdown
Contributor Author

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

False positive — there is no separate/mirrored ShortcutAction enum. The Settings keyboard-shortcuts UI is data-driven: cmuxApp.swift iterates KeyboardShortcutSettings.settingsVisibleActions (= Action.allCases.filter(isPublicShortcutAction), minus showHideAllWindows) and renders a ShortcutSettingRow per action. sendCtrlFToTerminal is public (isPublicShortcutAction defaults true; only the 5 sidebar-mode actions are excluded), so it already appears in Settings as a discoverable/bindable/resettable row. The shortcuts.bindings catalog is likewise generated by iterating publicShortcutActions in KeyboardShortcutSettingsFileStore+Template.swift, and cmux.json parsing resolves it via Action(rawValue: "sendCtrlFToTerminal"). No mirror to update.

— Claude Code

Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment

Labels

None yet

Projects

None yet

Development

Successfully merging this pull request may close these issues.

Ctrl+F not passed through to embedded Claude Code session (can't force-stop background agents)

1 participant