The best way to control Claude Code, Codex and more from any computer or phone
| 1 | import { EnvironmentId, ThreadId, type ResolvedKeybindingsConfig } from "@t3tools/contracts"; |
| 2 | import { compileResolvedKeybindingsConfig, isMacPlatform } from "@t3tools/shared/keybindings"; |
| 3 | import { describe, expect, it, vi } from "vite-plus/test"; |
| 4 | import { userEvent } from "vite-plus/test/browser"; |
| 5 | |
| 6 | import { act, fakeTimers, render } from "../../test/render"; |
| 7 | import { registerModelPickerContent } from "../modelPickerVisibility"; |
| 8 | import { useTerminalUiStateStore } from "../terminalUiStateStore"; |
| 9 | import { |
| 10 | THREAD_JUMP_HINT_SHOW_DELAY_MS, |
| 11 | useSnoozeWakeClock, |
| 12 | useThreadJumpHintsVisible, |
| 13 | } from "./Sidebar.logic"; |
| 14 | |
| 15 | const MOUNTED_AT_MS = Date.parse("2026-10-24T08:00:00.000Z"); |
| 16 | |
| 17 | function WakeClock(props: { readonly threads: ReadonlyArray<{ readonly snoozedUntil: string }> }) { |
| 18 | return <output>{useSnoozeWakeClock(props.threads)}</output>; |
| 19 | } |
| 20 | |
| 21 | describe("useSnoozeWakeClock", () => { |
| 22 | it("settles in one step when many distinct wakes passed during a sleep", async () => { |
| 23 | using now = vi.spyOn(Date, "now").mockReturnValue(MOUNTED_AT_MS); |
| 24 | // More distinct wakes than React's 25 render-phase re-render limit. |
| 25 | const threads = Array.from({ length: 40 }, (_, index) => ({ |
| 26 | snoozedUntil: new Date(MOUNTED_AT_MS + 1 + index * 60_000).toISOString(), |
| 27 | })); |
| 28 | await using screen = await render(<WakeClock threads={threads} />, { |
| 29 | // A bare hook host; nothing here links or navigates. |
| 30 | router: false, |
| 31 | }); |
| 32 | await expect.element(screen.getByRole("status")).toHaveTextContent(String(MOUNTED_AT_MS)); |
| 33 | |
| 34 | // The machine resumes after every wake has passed; the first wake's timer fires late. |
| 35 | const resumedAtMs = MOUNTED_AT_MS + 24 * 60 * 60_000; |
| 36 | now.mockReturnValue(resumedAtMs); |
| 37 | |
| 38 | // The clock lands on the last elapsed wake, so every woken thread has left the shelf. |
| 39 | const lastWakeMs = MOUNTED_AT_MS + 1 + 39 * 60_000; |
| 40 | await expect.element(screen.getByRole("status")).toHaveTextContent(String(lastWakeMs)); |
| 41 | }); |
| 42 | }); |
| 43 | |
| 44 | const ROUTE_THREAD_REF = { |
| 45 | environmentId: EnvironmentId.make("local"), |
| 46 | threadId: ThreadId.make("thread-1"), |
| 47 | }; |
| 48 | |
| 49 | function JumpHints(props: { readonly keybindings: ResolvedKeybindingsConfig }) { |
| 50 | const shown = useThreadJumpHintsVisible(props.keybindings, ROUTE_THREAD_REF); |
| 51 | return <output>{shown ? "shown" : "hidden"}</output>; |
| 52 | } |
| 53 | |
| 54 | describe("useThreadJumpHintsVisible", () => { |
| 55 | it("waits for the delay again on a second hold", async () => { |
| 56 | const keybindings = compileResolvedKeybindingsConfig([ |
| 57 | { key: "mod+1", command: "thread.jump.1" }, |
| 58 | ]); |
| 59 | const modifier = isMacPlatform(navigator.platform) ? "Meta" : "Control"; |
| 60 | await using screen = await render(<JumpHints keybindings={keybindings} />, { |
| 61 | // A bare hook host; nothing here links or navigates. |
| 62 | router: false, |
| 63 | }); |
| 64 | using _timers = fakeTimers(); |
| 65 | const output = screen.getByRole("status"); |
| 66 | |
| 67 | await userEvent.keyboard(`{${modifier}>}`); |
| 68 | await expect.element(output).toHaveTextContent("hidden"); |
| 69 | await act(() => vi.advanceTimersByTime(THREAD_JUMP_HINT_SHOW_DELAY_MS)); |
| 70 | await expect.element(output).toHaveTextContent("shown"); |
| 71 | |
| 72 | await userEvent.keyboard(`{/${modifier}}`); |
| 73 | await expect.element(output).toHaveTextContent("hidden"); |
| 74 | await act(() => vi.advanceTimersByTime(THREAD_JUMP_HINT_SHOW_DELAY_MS)); |
| 75 | |
| 76 | await userEvent.keyboard(`{${modifier}>}`); |
| 77 | await act(() => vi.advanceTimersByTime(THREAD_JUMP_HINT_SHOW_DELAY_MS - 1)); |
| 78 | await expect.element(output).toHaveTextContent("hidden"); |
| 79 | await act(() => vi.advanceTimersByTime(1)); |
| 80 | await expect.element(output).toHaveTextContent("shown"); |
| 81 | await userEvent.keyboard(`{/${modifier}}`); |
| 82 | }); |
| 83 | |
| 84 | it("follows terminal focus and the route thread's terminal while the modifier is held", async () => { |
| 85 | using stack = new DisposableStack(); |
| 86 | const terminal = document.createElement("div"); |
| 87 | terminal.dataset.terminalOwner = "drawer"; |
| 88 | const terminalInput = document.createElement("textarea"); |
| 89 | terminal.append(terminalInput); |
| 90 | document.body.append(terminal); |
| 91 | stack.defer(() => terminal.remove()); |
| 92 | stack.defer(() => useTerminalUiStateStore.getState().setTerminalOpen(ROUTE_THREAD_REF, false)); |
| 93 | const keybindings = compileResolvedKeybindingsConfig([ |
| 94 | { key: "mod+1", command: "thread.jump.1", when: "terminalOpen" }, |
| 95 | ]); |
| 96 | const modifier = isMacPlatform(navigator.platform) ? "Meta" : "Control"; |
| 97 | await using screen = await render(<JumpHints keybindings={keybindings} />, { |
| 98 | // A bare hook host; nothing here links or navigates. |
| 99 | router: false, |
| 100 | }); |
| 101 | using _timers = fakeTimers(); |
| 102 | const output = screen.getByRole("status"); |
| 103 | |
| 104 | await userEvent.keyboard(`{${modifier}>}`); |
| 105 | await act(() => vi.advanceTimersByTime(THREAD_JUMP_HINT_SHOW_DELAY_MS)); |
| 106 | await expect.element(output).toHaveTextContent("hidden"); |
| 107 | await act(() => useTerminalUiStateStore.getState().setTerminalOpen(ROUTE_THREAD_REF, true)); |
| 108 | await expect.element(output).toHaveTextContent("shown"); |
| 109 | await act(() => terminalInput.focus()); |
| 110 | await expect.element(output).toHaveTextContent("hidden"); |
| 111 | await act(() => terminalInput.blur()); |
| 112 | await expect.element(output).toHaveTextContent("shown"); |
| 113 | await userEvent.keyboard(`{/${modifier}}`); |
| 114 | await expect.element(output).toHaveTextContent("hidden"); |
| 115 | }); |
| 116 | |
| 117 | it("returns when the model picker closes while the modifier is still held", async () => { |
| 118 | const keybindings = compileResolvedKeybindingsConfig([ |
| 119 | { key: "mod+1", command: "thread.jump.1", when: "!modelPickerOpen" }, |
| 120 | ]); |
| 121 | const modifier = isMacPlatform(navigator.platform) ? "Meta" : "Control"; |
| 122 | await using screen = await render(<JumpHints keybindings={keybindings} />, { |
| 123 | // A bare hook host; nothing here links or navigates. |
| 124 | router: false, |
| 125 | }); |
| 126 | using _timers = fakeTimers(); |
| 127 | const output = screen.getByRole("status"); |
| 128 | |
| 129 | await userEvent.keyboard(`{${modifier}>}`); |
| 130 | await act(() => vi.advanceTimersByTime(THREAD_JUMP_HINT_SHOW_DELAY_MS)); |
| 131 | await expect.element(output).toHaveTextContent("shown"); |
| 132 | let unregisterModelPicker = () => {}; |
| 133 | await act(() => { |
| 134 | unregisterModelPicker = registerModelPickerContent(); |
| 135 | }); |
| 136 | await expect.element(output).toHaveTextContent("hidden"); |
| 137 | await act(() => unregisterModelPicker()); |
| 138 | await expect.element(output).toHaveTextContent("shown"); |
| 139 | await userEvent.keyboard(`{/${modifier}}`); |
| 140 | }); |
| 141 | |
| 142 | it("shows after the delay for a jump binding without a modifier", async () => { |
| 143 | const keybindings = compileResolvedKeybindingsConfig([{ key: "f1", command: "thread.jump.1" }]); |
| 144 | // Mounting starts the hold delay. |
| 145 | using _timers = fakeTimers(); |
| 146 | await using screen = await render(<JumpHints keybindings={keybindings} />, { |
| 147 | // A bare hook host; nothing here links or navigates. |
| 148 | router: false, |
| 149 | }); |
| 150 | const output = screen.getByRole("status"); |
| 151 | |
| 152 | await act(() => vi.advanceTimersByTime(THREAD_JUMP_HINT_SHOW_DELAY_MS)); |
| 153 | await expect.element(output).toHaveTextContent("shown"); |
| 154 | }); |
| 155 | }); |