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

main
tsx 353 lines 14.5 KB
Raw
1 import { useAtomValue } from "@effect/atom-react";
2 import { thrownErrorMessage } from "@t3tools/client-runtime/errors";
3 import { scopeThreadRef } from "@t3tools/client-runtime/environment";
4 import {
5 AuthPreviewOperateScope,
6 AuthTerminalOperateScope,
7 type DiscoveredLocalServer,
8 type EnvironmentId,
9 type ThreadId,
10 } from "@t3tools/contracts";
11 import {
12 isAtomCommandInterrupted,
13 squashAtomCommandFailure,
14 } from "@t3tools/client-runtime/state/runtime";
15 import { isLoopbackHost } from "@t3tools/shared/preview";
16 import { T, useGT, Var } from "gt-react";
17 import { m } from "~/i18n/messages";
18 import { CableIcon, GlobeIcon, SquareIcon, ChevronDownIcon, ChevronUpIcon } from "lucide-react";
19 import { type MouseEvent, useState } from "react";
20
21 import {
22 resolveExternalServerUrl,
23 tunnelsEnvironmentLoopback,
24 } from "../../browser/browserTargetResolver";
25 import { readLocalApi } from "../../localApi";
26 import { cn, isMacPlatform } from "../../lib/utils";
27 import { useThreadDiscoveredPorts } from "../../portDiscoveryState";
28 import { useEnvironment } from "../../state/environments";
29 import {
30 canForwardPorts,
31 findPortForward,
32 forwardedUrl,
33 forwardPort,
34 stopPortForward,
35 useForwardLocality,
36 usePortForwards,
37 } from "../../state/portForwards";
38 import { previewEnvironment } from "../../state/preview";
39 import { useEnvironmentScope } from "../../state/session";
40 import { useAtomCommand } from "../../state/use-atom-command";
41 import { openDiscoveredPort } from "../preview/openDiscoveredPort";
42 import { Spinner } from "../ui/spinner";
43 import { stackedThreadToast, toastManager } from "../ui/toast";
44 import { Tooltip, TooltipPopup, TooltipTrigger } from "../ui/tooltip";
45 import { ThreadDetailsControl } from "./ThreadDetailsControl";
46 import { ThreadDetailsSection } from "./ThreadDetailsSection";
47 import { THREAD_DETAILS_PANEL_ICON_CLASS } from "./threadDetailsPanelStyles";
48
49 const SERVER_PAGE_COUNT = 4;
50
51 const serverKey = (server: DiscoveredLocalServer) => `${server.pid}:${server.port}`;
52
53 interface ThreadServersPanelProps {
54 readonly environmentId: EnvironmentId;
55 readonly threadId: ThreadId;
56 }
57
58 /** Local servers the thread's terminals and agent started. Hidden while none run. */
59 export function ThreadServersPanel(props: ThreadServersPanelProps) {
60 return <ThreadServersList key={`${props.environmentId}:${props.threadId}`} {...props} />;
61 }
62
63 function ThreadServersList(props: ThreadServersPanelProps) {
64 const gt = useGT();
65 const servers = useThreadDiscoveredPorts(props);
66 const canOpen = useEnvironmentScope(props.environmentId, AuthPreviewOperateScope);
67 const canStop = useAtomValue(
68 previewEnvironment.stopLocalServer.permissionAtom(props.environmentId),
69 );
70 const environment = useEnvironment(props.environmentId);
71 const supportsStop = environment?.serverConfig?.environment.capabilities.localServerStop === true;
72 const forwards = usePortForwards();
73 const forwardable =
74 useEnvironmentScope(props.environmentId, AuthTerminalOperateScope) &&
75 environment?.connection.phase === "connected" &&
76 canForwardPorts(environment);
77 const locality = useForwardLocality(forwardable ? props.environmentId : null);
78 const canForward = locality === "remote";
79 const openPreview = useAtomCommand(previewEnvironment.open, { reportFailure: false });
80 const stopServer = useAtomCommand(previewEnvironment.stopLocalServer, {
81 label: "thread server stop",
82 });
83 const [stoppingKey, setStoppingKey] = useState<string | null>(null);
84 const [forwardingPort, setForwardingPort] = useState<number | null>(null);
85 const [visibleCount, setVisibleCount] = useState(SERVER_PAGE_COUNT);
86
87 if (servers.length === 0) return null;
88 const externalClickLabel = isMacPlatform(navigator.platform) ? "⌘-click" : "Ctrl-click";
89 const threadRef = scopeThreadRef(props.environmentId, props.threadId);
90 const hiddenCount = Math.max(0, servers.length - visibleCount);
91
92 const reportFailure = (title: string, error: unknown) => {
93 toastManager.add(
94 stackedThreadToast({
95 type: "error",
96 title,
97 description: thrownErrorMessage(error, m) ?? String(error),
98 }),
99 );
100 };
101
102 const open = async (server: DiscoveredLocalServer, event: MouseEvent<HTMLElement>) => {
103 if (event.button > 1) return;
104 // Like links: modified and middle clicks go to the system browser.
105 if (event.metaKey || event.ctrlKey || event.button === 1) {
106 event.preventDefault();
107 // This machine's browser reaches another environment's loopback only through a forward.
108 // Starting a forward runs the probe; only a confirmed local environment opens directly.
109 const url =
110 forwardable && locality !== "local"
111 ? await forwardPort(props.environmentId, server.port).then(
112 (forward) => forwardedUrl(forward, server.url),
113 (error: unknown) => {
114 reportFailure(gt("Could not forward port {port}", { port: server.port }), error);
115 return null;
116 },
117 )
118 : resolveExternalServerUrl(props.environmentId, server.url);
119 if (url === null) return;
120 // Without a forward, a remote environment's localhost would open this machine's instead.
121 if (
122 locality !== "local" &&
123 tunnelsEnvironmentLoopback(environment?.entry.target) &&
124 isLoopbackHost(new URL(url).hostname)
125 ) {
126 reportFailure(
127 gt("Unable to open in browser"),
128 new Error(
129 gt(
130 "localhost:{port} runs on another machine, and port forwarding isn't available for it right now.",
131 { port: server.port },
132 ),
133 ),
134 );
135 return;
136 }
137 await readLocalApi()
138 ?.shell.openExternal(url)
139 .catch((error: unknown) => reportFailure(gt("Unable to open in browser"), error));
140 return;
141 }
142 const result = await openDiscoveredPort({ threadRef, port: server, openPreview });
143 if (result._tag === "Failure" && !isAtomCommandInterrupted(result)) {
144 reportFailure(gt("Unable to open preview"), squashAtomCommandFailure(result));
145 }
146 };
147
148 const stop = async (server: DiscoveredLocalServer) => {
149 if (server.pid === null || stoppingKey !== null) return;
150 setStoppingKey(serverKey(server));
151 const result = await stopServer({
152 environmentId: props.environmentId,
153 input: { pid: server.pid, port: server.port },
154 });
155 setStoppingKey(null);
156 if (result._tag === "Failure" && !isAtomCommandInterrupted(result)) {
157 reportFailure(gt("Could not stop server"), squashAtomCommandFailure(result));
158 }
159 };
160
161 const toggleForward = async (server: DiscoveredLocalServer, forwarded: boolean) => {
162 if (forwardingPort !== null) return;
163 setForwardingPort(server.port);
164 await (
165 forwarded
166 ? stopPortForward(props.environmentId, server.port)
167 : forwardPort(props.environmentId, server.port)
168 ).catch((error: unknown) =>
169 reportFailure(gt("Could not forward port {port}", { port: server.port }), error),
170 );
171 setForwardingPort(null);
172 };
173
174 return (
175 <ThreadDetailsSection
176 headingId="thread-details-servers-heading"
177 title={gt("Servers", { $context: "thread details section: running dev servers" })}
178 >
179 <ul className="m-0 list-none p-0">
180 {servers.slice(0, visibleCount).map((server, index) => {
181 const key = serverKey(server);
182 const stoppable = canStop && supportsStop && server.pid !== null;
183 const forward = findPortForward(forwards, props.environmentId, server.port);
184 const actionCount = Number(stoppable) + Number(canForward);
185 return (
186 <li
187 key={key}
188 data-thread-details-server-overflow={index >= SERVER_PAGE_COUNT || undefined}
189 className="group relative flex items-center rounded-lg"
190 >
191 <Tooltip>
192 <TooltipTrigger
193 delay={200}
194 render={
195 <ThreadDetailsControl
196 size="sm"
197 variant="ghost"
198 part="row"
199 multiline
200 disabled={!canOpen}
201 onClick={(event) => void open(server, event)}
202 onAuxClick={(event) => void open(server, event)}
203 />
204 }
205 >
206 <GlobeIcon aria-hidden className={THREAD_DETAILS_PANEL_ICON_CLASS} />
207 {/* The end padding keeps text clear of the stop button. */}
208 <span
209 className={cn(
210 "flex min-w-0 flex-1 flex-col gap-0.5",
211 actionCount === 1 && "pe-6",
212 actionCount === 2 && "pe-12",
213 )}
214 >
215 <span className="truncate text-sm font-medium leading-4 text-foreground/85">
216 localhost:{server.port}
217 </span>
218 <span className="truncate text-2xs font-normal leading-4 text-muted-foreground">
219 {[
220 // First, so the narrow panel truncates the less useful parts.
221 forward
222 ? gt("Forwarded to :{port}", {
223 $context: "a remote dev server reachable on this machine's port",
224 port: forward.localPort,
225 })
226 : null,
227 server.terminal === null
228 ? gt("Agent", { $context: "who started a dev server" })
229 : gt("Terminal", { $context: "who started a dev server" }),
230 server.processName,
231 ]
232 .filter(Boolean)
233 .join(" · ")}
234 </span>
235 </span>
236 </TooltipTrigger>
237 <TooltipPopup side="left">
238 <T>
239 Open in the browser panel. <Var>{externalClickLabel}</Var> for your browser.
240 </T>
241 </TooltipPopup>
242 </Tooltip>
243 {actionCount > 0 ? (
244 <div
245 className={cn(
246 "absolute right-1 top-1/2 flex -translate-y-1/2 items-center gap-0.5",
247 // A forward stays visible: it holds a port on this machine.
248 !forward &&
249 "pointer-events-none opacity-0 group-hover:pointer-events-auto group-hover:opacity-100 group-focus-within:pointer-events-auto group-focus-within:opacity-100 pointer-coarse:pointer-events-auto pointer-coarse:opacity-100 [@media(hover:none)]:pointer-events-auto [@media(hover:none)]:opacity-100",
250 )}
251 >
252 {canForward ? (
253 <Tooltip>
254 <TooltipTrigger
255 render={
256 <ThreadDetailsControl
257 size="icon-xs"
258 variant="ghost"
259 part="icon"
260 aria-pressed={forward !== undefined}
261 aria-label={
262 forward
263 ? gt("Stop forwarding localhost:{port}", { port: server.port })
264 : gt("Forward localhost:{port} to this machine", {
265 port: server.port,
266 })
267 }
268 disabled={forwardingPort !== null}
269 onClick={() => void toggleForward(server, forward !== undefined)}
270 />
271 }
272 >
273 {forwardingPort === server.port ? (
274 <Spinner aria-hidden size="xs" />
275 ) : (
276 <CableIcon
277 aria-hidden
278 className={cn("size-3.5", forward && "text-primary")}
279 />
280 )}
281 </TooltipTrigger>
282 <TooltipPopup side="left">
283 {forward ? (
284 <T>
285 Forwarded to localhost:<Var>{forward.localPort}</Var> on this machine.
286 Click to stop.
287 </T>
288 ) : (
289 <T>Forward to this machine, for any app here</T>
290 )}
291 </TooltipPopup>
292 </Tooltip>
293 ) : null}
294 {stoppable ? (
295 <Tooltip>
296 <TooltipTrigger
297 render={
298 <ThreadDetailsControl
299 size="icon-xs"
300 variant="ghost"
301 part="icon"
302 tone="destructive"
303 aria-label={gt("Stop localhost:{port}", { port: server.port })}
304 disabled={stoppingKey !== null}
305 onClick={() => void stop(server)}
306 />
307 }
308 >
309 {stoppingKey === key ? (
310 <Spinner aria-hidden size="xs" />
311 ) : (
312 <SquareIcon aria-hidden className="size-3 fill-current" />
313 )}
314 </TooltipTrigger>
315 <TooltipPopup side="left">
316 <T>Stop server</T>
317 </TooltipPopup>
318 </Tooltip>
319 ) : null}
320 </div>
321 ) : null}
322 </li>
323 );
324 })}
325 </ul>
326 {servers.length > SERVER_PAGE_COUNT ? (
327 <ThreadDetailsControl
328 variant="ghost"
329 size="sm"
330 onClick={() =>
331 setVisibleCount(hiddenCount > 0 ? visibleCount + SERVER_PAGE_COUNT : SERVER_PAGE_COUNT)
332 }
333 part="row"
334 tone="muted"
335 className="w-full active:scale-100"
336 >
337 {hiddenCount > 0 ? (
338 <ChevronDownIcon aria-hidden className="size-4 shrink-0" />
339 ) : (
340 <ChevronUpIcon aria-hidden className="size-4 shrink-0" />
341 )}
342 {hiddenCount > 0 ? (
343 <T>
344 Show <Var>{Math.min(hiddenCount, SERVER_PAGE_COUNT)}</Var> more
345 </T>
346 ) : (
347 <T>Show less</T>
348 )}
349 </ThreadDetailsControl>
350 ) : null}
351 </ThreadDetailsSection>
352 );
353 }