The best way to control Claude Code, Codex and more from any computer or phone

main
tsx 199 lines 6.51 KB
Raw
1 import {
2 applyTerminalAttachStreamEvent,
3 EMPTY_TERMINAL_BUFFER_STATE,
4 terminalOutputReplay,
5 } from "@t3tools/client-runtime/state/terminal";
6 import { act, useImperativeHandle, useLayoutEffect, type ReactNode } from "react";
7 import { createRoot } from "react-dom/client";
8 import type { NativeSyntheticEvent } from "react-native";
9 import { expect, it, vi } from "vite-plus/test";
10
11 import type { NativeTerminalSurfaceProps } from "./nativeTerminalModule";
12
13 const mocks = vi.hoisted(() => ({
14 revision: null as number | null,
15 initialBuffers: [] as string[],
16 mounts: vi.fn(),
17 unmounts: vi.fn(),
18 write: vi.fn(async (_data: string, _reset: boolean) => {}),
19 paste: (_text: string) => {},
20 }));
21
22 function RawView({ ref: nativeRef, initialBuffer, onResize, onPaste }: NativeTerminalSurfaceProps) {
23 useLayoutEffect(() => {
24 mocks.paste = (text) =>
25 onPaste?.({ nativeEvent: { text } } as NativeSyntheticEvent<{ text: string }>);
26 return () => {
27 mocks.paste = () => {};
28 };
29 }, [onPaste]);
30 useImperativeHandle(nativeRef, () => ({ writeOutput: mocks.write }));
31 useLayoutEffect(() => {
32 mocks.mounts();
33 return () => {
34 mocks.unmounts();
35 };
36 }, []);
37 useLayoutEffect(() => {
38 mocks.initialBuffers.push(initialBuffer);
39 }, [initialBuffer]);
40 useLayoutEffect(() => {
41 onResize?.({ nativeEvent: { cols: 80, rows: 24 } } as NativeSyntheticEvent<{
42 cols: number;
43 rows: number;
44 }>);
45 }, [onResize]);
46 return null;
47 }
48
49 vi.mock("expo", () => ({
50 requireNativeView: () => RawView,
51 requireOptionalNativeModule: () =>
52 mocks.revision === null ? {} : { outputRevision: mocks.revision },
53 }));
54 vi.mock("react-native", () => ({ View: ({ children }: { children: ReactNode }) => children }));
55 vi.mock("../../components/ui/AppText", () => ({ AppText: () => null }));
56 vi.mock("../../lib/typography", () => ({ MOBILE_TYPOGRAPHY: { label: { fontSize: 10 } } }));
57 vi.mock("../settings/appearance/AppearancePreferencesProvider", () => ({
58 useAppearancePreferences: () => ({ themeAppearance: "dark", themeId: "default" }),
59 }));
60 vi.mock("./terminalTheme", () => ({
61 buildGhosttyThemeConfig: () => "theme",
62 getMobileTerminalTheme: () => ({}),
63 }));
64
65 import { TerminalSurface } from "./NativeTerminalSurface";
66
67 function setup(revision: number | null) {
68 mocks.revision = revision;
69 mocks.initialBuffers = [];
70 mocks.write.mockReset();
71 mocks.write.mockResolvedValue(undefined);
72 mocks.mounts.mockClear();
73 mocks.unmounts.mockClear();
74 mocks.paste = () => {};
75 const document = { nodeType: 9, addEventListener() {}, removeEventListener() {} };
76 const container = {
77 nodeType: 1,
78 tagName: "DIV",
79 namespaceURI: "http://www.w3.org/1999/xhtml",
80 ownerDocument: document,
81 addEventListener() {},
82 removeEventListener() {},
83 };
84 vi.stubGlobal("document", document);
85 vi.stubGlobal("window", { document, HTMLIFrameElement: EventTarget });
86 vi.stubGlobal("expo", { getViewConfig: () => ({}) });
87 vi.stubGlobal("IS_REACT_ACT_ENVIRONMENT", true);
88 const root = createRoot(container as unknown as HTMLElement);
89 return {
90 async render(
91 state: typeof EMPTY_TERMINAL_BUFFER_STATE,
92 terminalKey = "environment:thread:term-1",
93 input: {
94 isRunning?: boolean;
95 readOnly?: boolean;
96 onPaste?: (text: string) => void;
97 } = {},
98 ) {
99 await act(async () => {
100 root.render(
101 <TerminalSurface
102 terminalKey={terminalKey}
103 output={state.version === 0 ? null : state.output}
104 buffer={
105 state.version === 0
106 ? null
107 : (revision ?? 0) >= 1
108 ? ""
109 : terminalOutputReplay(state.output)
110 }
111 isRunning
112 onInput={() => {}}
113 onResize={() => {}}
114 {...input}
115 />,
116 );
117 });
118 },
119 async [Symbol.asyncDispose]() {
120 await act(async () => root.unmount());
121 vi.unstubAllGlobals();
122 },
123 };
124 }
125
126 it.each([null, 1])(
127 "preserves the native view across rollover and uses legacy history on older binaries (revision %s)",
128 async (revision) => {
129 await using harness = setup(revision);
130 let state = applyTerminalAttachStreamEvent(
131 EMPTY_TERMINAL_BUFFER_STATE,
132 {
133 type: "output",
134 threadId: "thread",
135 terminalId: "term-1",
136 data: "retained",
137 },
138 8,
139 );
140 await harness.render(state);
141 state = applyTerminalAttachStreamEvent(
142 state,
143 {
144 type: "output",
145 threadId: "thread",
146 terminalId: "term-1",
147 data: "-new",
148 },
149 8,
150 );
151 await harness.render(state);
152 await harness.render(EMPTY_TERMINAL_BUFFER_STATE);
153 expect(mocks.mounts).toHaveBeenCalledTimes(1);
154 expect(mocks.unmounts).not.toHaveBeenCalled();
155 if (revision === 1) {
156 expect(mocks.initialBuffers).toEqual([""]);
157 expect(mocks.write.mock.calls).toEqual([
158 ["retained", true],
159 ["-new", false],
160 ]);
161 await harness.render(state, "another-environment:thread:term-1");
162 expect(mocks.write).toHaveBeenLastCalledWith("ined-new", true);
163 } else {
164 expect(mocks.write).not.toHaveBeenCalled();
165 expect(mocks.initialBuffers).toEqual(["retained", "ined-new"]);
166 // An older binary recreates its emulator unless the next buffer extends the last one.
167 // The buffer is full here, so the erase must not push the earlier output out.
168 let cleared = applyTerminalAttachStreamEvent(
169 state,
170 { type: "output", threadId: "thread", terminalId: "term-1", data: "\u001b[?1049h" },
171 16,
172 );
173 await harness.render(cleared);
174 cleared = applyTerminalAttachStreamEvent(
175 cleared,
176 { type: "cleared", threadId: "thread", terminalId: "term-1" },
177 16,
178 );
179 await harness.render(cleared);
180 expect(mocks.initialBuffers.slice(2)).toEqual([
181 "ined-new\u001b[?1049h",
182 "ined-new\u001b[?1049h\u001b[H\u001b[2J\u001b[3J",
183 ]);
184 }
185 },
186 );
187
188 it("forwards a native paste only while the terminal is writable and running", async () => {
189 await using harness = setup(1);
190 const pasted: string[] = [];
191 const onPaste = (text: string) => pasted.push(text);
192 await harness.render(EMPTY_TERMINAL_BUFFER_STATE, undefined, { onPaste });
193 mocks.paste("one\ntwo");
194 await harness.render(EMPTY_TERMINAL_BUFFER_STATE, undefined, { onPaste, readOnly: true });
195 mocks.paste("read-only");
196 await harness.render(EMPTY_TERMINAL_BUFFER_STATE, undefined, { onPaste, isRunning: false });
197 mocks.paste("exited");
198 expect(pasted).toEqual(["one\ntwo"]);
199 });