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

main
tsx 186 lines 6.81 KB
Raw
1 import { thrownErrorMessage } from "@t3tools/client-runtime/errors";
2 import { useNavigate } from "@tanstack/react-router";
3 import {
4 type AtomCommandResult,
5 isAtomCommandInterrupted,
6 squashAtomCommandFailure,
7 } from "@t3tools/client-runtime/state/runtime";
8 import { AuthAccessWriteScope, type EnvironmentId } from "@t3tools/contracts";
9 import * as DateTime from "effect/DateTime";
10 import { useEffect, useRef, useState } from "react";
11 import { msg } from "gt-react";
12
13 import { m } from "../i18n/messages";
14 import { authEnvironment } from "../state/auth";
15 import { useEnvironments } from "../state/environments";
16 import { useEnvironmentQuery } from "../state/query";
17 import { useEnvironmentScope } from "../state/session";
18 import { useAtomCommand } from "../state/use-atom-command";
19 import { describeConnectDeviceClient } from "./settings/ConnectionsSettings.logic";
20 import { toastManager } from "./ui/toast";
21 import { stackedThreadToast } from "./ui/toastHelpers";
22
23 /** Asks whoever can approve to look at T3 Connect devices waiting on an environment. */
24 export function ConnectDeviceApprovalCoordinator() {
25 const { environments } = useEnvironments();
26 return environments.map((environment) =>
27 environment.connection.phase === "connected" &&
28 environment.serverConfig?.settings.requireConnectDeviceApproval === true ? (
29 <EnvironmentConnectDeviceRequests
30 key={environment.environmentId}
31 environmentId={environment.environmentId}
32 environmentLabel={environment.label}
33 />
34 ) : null,
35 );
36 }
37
38 function EnvironmentConnectDeviceRequests(props: {
39 readonly environmentId: EnvironmentId;
40 readonly environmentLabel: string;
41 }) {
42 const canApprove = useEnvironmentScope(props.environmentId, AuthAccessWriteScope);
43 return canApprove ? <ConnectDeviceRequestToasts {...props} /> : null;
44 }
45
46 /** Reports a failed command and says whether it failed, so its request can be offered again. */
47 async function reportFailure(
48 title: string,
49 action: () => Promise<AtomCommandResult<unknown, unknown>>,
50 ): Promise<boolean> {
51 const result = await action();
52 if (result._tag !== "Failure") return false;
53 if (!isAtomCommandInterrupted(result)) {
54 const error = squashAtomCommandFailure(result);
55 toastManager.add(
56 stackedThreadToast({
57 type: "error",
58 title,
59 description: thrownErrorMessage(error, m) ?? m(msg("An error occurred.")),
60 }),
61 );
62 }
63 return true;
64 }
65
66 function ConnectDeviceRequestToasts({
67 environmentId,
68 environmentLabel,
69 }: {
70 readonly environmentId: EnvironmentId;
71 readonly environmentLabel: string;
72 }) {
73 const navigate = useNavigate();
74 const access = useEnvironmentQuery(authEnvironment.accessChanges({ environmentId, input: null }));
75 const approve = useAtomCommand(authEnvironment.approveConnectDevice, { reportFailure: false });
76 const deny = useAtomCommand(authEnvironment.revokePairingLink, { reportFailure: false });
77 const toasts = useRef(new Map<string, { toastId: string; renderedKey: string }>());
78 const [, setRetryGeneration] = useState(0);
79 // A failed approve or deny forgets its toast and re-renders, so the request is offered again.
80 const settle = async (id: string, failed: Promise<boolean>) => {
81 if (!(await failed)) return;
82 toasts.current.delete(id);
83 setRetryGeneration((generation) => generation + 1);
84 };
85
86 const requests =
87 access.data?.type === "snapshot"
88 ? access.data.payload.pairingLinks.flatMap((link) =>
89 link.connectDeviceRequest
90 ? [{ id: link.id, request: link.connectDeviceRequest, expiresAt: link.expiresAt }]
91 : [],
92 )
93 : null;
94
95 // oxlint-disable-next-line t3code/no-unreasoned-state-sync -- opens, updates and closes imperative toastManager toasts to match the pending requests
96 useEffect(() => {
97 if (requests === null) return;
98 // The server publishes no event when a request expires, so the toast ends itself then.
99 const now = Date.now();
100 const live = requests.flatMap((entry) => {
101 const remainingMs = DateTime.toEpochMillis(entry.expiresAt) - now;
102 return remainingMs > 0 ? [{ ...entry, remainingMs }] : [];
103 });
104 const pendingIds = new Set(live.map(({ id }) => id));
105 for (const [id, tracked] of toasts.current) {
106 if (pendingIds.has(id)) continue;
107 toastManager.close(tracked.toastId);
108 toasts.current.delete(id);
109 }
110 for (const { id, request, remainingMs } of live) {
111 const device = describeConnectDeviceClient(request);
112 const renderedKey = `${request.verificationCode}:${device}`;
113 const tracked = toasts.current.get(id);
114 if (tracked?.renderedKey === renderedKey) continue;
115 const close = () => {
116 const current = toasts.current.get(id);
117 if (current) toastManager.close(current.toastId);
118 };
119 const options = stackedThreadToast({
120 type: "info",
121 title: m(msg("A device wants to connect to {environmentLabel}", { environmentLabel })),
122 description: m(
123 msg("{device}. Approve only if it shows code {code}.", {
124 device,
125 code: request.verificationCode,
126 }),
127 ),
128 timeout: remainingMs,
129 actionProps: {
130 children: m(msg("Approve")),
131 onClick: () => {
132 close();
133 void settle(
134 id,
135 reportFailure(m(msg("Could not approve the device")), () =>
136 approve({ environmentId, input: { pairingLinkId: id } }),
137 ),
138 );
139 },
140 },
141 data: {
142 hideCopyButton: true,
143 secondaryActionProps: {
144 children: m(msg("Deny")),
145 onClick: () => {
146 close();
147 void settle(
148 id,
149 reportFailure(m(msg("Could not deny the device")), () =>
150 deny({ environmentId, input: { id } }),
151 ),
152 );
153 },
154 },
155 additionalActions: [
156 {
157 id: "review",
158 props: {
159 children: m(msg("Review", { $context: "verb, opens the device in settings" })),
160 onClick: () =>
161 void navigate({ to: "/settings/access", search: { machine: environmentId } }),
162 },
163 },
164 ],
165 },
166 });
167 if (tracked) {
168 toastManager.update(tracked.toastId, options);
169 toasts.current.set(id, { toastId: tracked.toastId, renderedKey });
170 } else {
171 toasts.current.set(id, { toastId: toastManager.add(options), renderedKey });
172 }
173 }
174 });
175
176 // oxlint-disable-next-line t3code/no-unreasoned-state-sync -- closes this environment's imperative toasts when it stops needing approval
177 useEffect(() => {
178 const tracked = toasts.current;
179 return () => {
180 for (const { toastId } of tracked.values()) toastManager.close(toastId);
181 tracked.clear();
182 };
183 }, []);
184
185 return null;
186 }