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

main
ts 547 lines 18.4 KB
Raw
1 import { thrownErrorMessage } from "@t3tools/client-runtime/errors";
2 import {
3 defaultInstanceIdForDriver,
4 PROVIDER_DISPLAY_NAMES,
5 type EnvironmentId,
6 type ProviderDriverKind,
7 type ProviderInstanceId,
8 type ServerProvider,
9 } from "@t3tools/contracts";
10 import {
11 isAtomCommandInterrupted,
12 squashAtomCommandFailure,
13 type AtomCommandResult,
14 } from "@t3tools/client-runtime/state/runtime";
15 import { msg } from "gt-react";
16
17 import { m, type MessageResolver } from "../i18n/messages";
18
19 export type ProviderUpdateCandidate = ServerProvider & {
20 readonly versionAdvisory: NonNullable<ServerProvider["versionAdvisory"]> & {
21 readonly status: "behind_latest";
22 readonly latestVersion: string;
23 };
24 };
25
26 export type ProviderSettingsUpdateCandidate = ServerProvider & {
27 readonly versionAdvisory: NonNullable<ServerProvider["versionAdvisory"]> & {
28 readonly canUpdate: true;
29 readonly updateCommand: string;
30 };
31 };
32
33 export type ProviderUpdateSidebarPillTone = "loading" | "warning" | "error" | "success";
34
35 export interface ProviderUpdateSidebarPillView {
36 readonly key: string;
37 readonly tone: ProviderUpdateSidebarPillTone;
38 readonly title: string;
39 readonly description: string;
40 readonly dismissible?: boolean;
41 readonly dismissAfterVisibleMs?: number;
42 readonly dismissKeys?: ReadonlyArray<string>;
43 }
44
45 interface ProviderUpdateSidebarPillOptions {
46 readonly visibleAfterIso?: string;
47 readonly dismissedKeys?: ReadonlySet<string>;
48 }
49
50 const PROVIDER_UPDATE_SUCCESS_VISIBLE_MS = 3_000;
51
52 function formatVersion(value: string): string {
53 return value.startsWith("v") ? value : `v${value}`;
54 }
55
56 function chooseRepresentativeProvider(
57 current: ServerProvider | undefined,
58 candidate: ServerProvider,
59 ): ServerProvider {
60 if (!current) {
61 return candidate;
62 }
63 const defaultInstanceId = defaultInstanceIdForDriver(candidate.driver);
64 if (candidate.instanceId === defaultInstanceId) {
65 return candidate;
66 }
67 if (current.instanceId === defaultInstanceId) {
68 return current;
69 }
70 return candidate.checkedAt.localeCompare(current.checkedAt) >= 0 ? candidate : current;
71 }
72
73 function dedupeProvidersByDriver<T extends ServerProvider>(providers: ReadonlyArray<T>): T[] {
74 const latestProviderByDriver = new Map<ProviderDriverKind, T>();
75
76 for (const provider of providers) {
77 latestProviderByDriver.set(
78 provider.driver,
79 chooseRepresentativeProvider(latestProviderByDriver.get(provider.driver), provider) as T,
80 );
81 }
82
83 return [...latestProviderByDriver.values()];
84 }
85
86 function getProviderUpdatedTitle(
87 provider: Pick<ServerProvider, "driver" | "version" | "installedVersion">,
88 resolve: MessageResolver,
89 ): string {
90 const providerName = PROVIDER_DISPLAY_NAMES[provider.driver] ?? provider.driver;
91 const version = provider.installedVersion ?? provider.version;
92 return version
93 ? resolve(
94 msg("{provider} updated: {version}", {
95 provider: providerName,
96 version: formatVersion(version),
97 }),
98 )
99 : resolve(msg("{provider} updated", { provider: providerName }));
100 }
101
102 // Only OpenCode reports an installed CLI apart from a running external server.
103 export function getProviderRestartNotice(
104 provider: Pick<ServerProvider, "version" | "installedVersion" | "updateState">,
105 ): string | null {
106 return provider.updateState?.status === "succeeded" &&
107 provider.installedVersion != null &&
108 provider.version != null &&
109 provider.installedVersion !== provider.version
110 ? provider.updateState.message
111 : null;
112 }
113
114 function getProviderUpdatedDescription(providerCount: number, resolve: MessageResolver): string {
115 return providerCount === 1
116 ? resolve(msg("New sessions will use the updated provider."))
117 : resolve(msg("New sessions will use the updated providers."));
118 }
119
120 function getProviderFailedUpdateTitle(
121 provider: Pick<ServerProvider, "driver" | "versionAdvisory">,
122 resolve: MessageResolver,
123 ): string {
124 const providerName = PROVIDER_DISPLAY_NAMES[provider.driver] ?? provider.driver;
125 const attemptedVersion = provider.versionAdvisory?.latestVersion;
126 return attemptedVersion
127 ? resolve(
128 msg("{provider} {version} update failed", {
129 provider: providerName,
130 version: formatVersion(attemptedVersion),
131 }),
132 )
133 : resolve(msg("{provider} update failed", { provider: providerName }));
134 }
135
136 export function isProviderUpdateCandidate(
137 provider: ServerProvider,
138 ): provider is ProviderUpdateCandidate {
139 return (
140 provider.enabled &&
141 provider.compatibilityAdvisory?.latestVersionStatus !== "broken" &&
142 provider.compatibilityAdvisory?.latestVersionStatus !== "unsupported" &&
143 provider.versionAdvisory?.status === "behind_latest" &&
144 provider.versionAdvisory.latestVersion !== null
145 );
146 }
147
148 export function isProviderUpdateActive(provider: Pick<ServerProvider, "updateState">): boolean {
149 return provider.updateState?.status === "queued" || provider.updateState?.status === "running";
150 }
151
152 export function collectProviderUpdateCandidates(
153 providers: ReadonlyArray<ServerProvider>,
154 ): ProviderUpdateCandidate[] {
155 return dedupeProvidersByDriver(providers.filter(isProviderUpdateCandidate));
156 }
157
158 export function isProviderSettingsUpdateCandidate(
159 provider: ServerProvider,
160 ): provider is ProviderSettingsUpdateCandidate {
161 return (
162 provider.enabled &&
163 provider.compatibilityAdvisory?.latestVersionStatus !== "broken" &&
164 provider.compatibilityAdvisory?.latestVersionStatus !== "unsupported" &&
165 provider.versionAdvisory?.status === "behind_latest" &&
166 provider.versionAdvisory.canUpdate === true &&
167 provider.versionAdvisory.updateCommand !== null
168 );
169 }
170
171 export function hasOneClickUpdateProviderCandidate(
172 candidate: ProviderUpdateCandidate,
173 providers: ReadonlyArray<ServerProvider>,
174 ): boolean {
175 if (
176 candidate.versionAdvisory.canUpdate !== true ||
177 candidate.versionAdvisory.updateCommand === null
178 ) {
179 return false;
180 }
181
182 const driverProviders = providers.filter((provider) => provider.driver === candidate.driver);
183 if (driverProviders.length === 0) {
184 return false;
185 }
186
187 const updateCommands = new Set<string>();
188 for (const provider of driverProviders) {
189 if (!isProviderUpdateCandidate(provider)) {
190 continue;
191 }
192 const advisory = provider.versionAdvisory;
193 if (!advisory || advisory.canUpdate !== true || advisory.updateCommand === null) {
194 return false;
195 }
196 updateCommands.add(advisory.updateCommand);
197 }
198
199 return updateCommands.size === 1;
200 }
201
202 export function canOneClickUpdateProviderCandidate(
203 candidate: ProviderUpdateCandidate,
204 providers: ReadonlyArray<ServerProvider>,
205 ): boolean {
206 return (
207 !isProviderUpdateActive(candidate) && hasOneClickUpdateProviderCandidate(candidate, providers)
208 );
209 }
210
211 function formatProviderList(
212 providers: ReadonlyArray<Pick<ServerProvider, "driver">>,
213 resolve: MessageResolver,
214 ) {
215 const names = providers.map(
216 (provider) => PROVIDER_DISPLAY_NAMES[provider.driver] ?? provider.driver,
217 );
218 if (names.length <= 1) return names.join("");
219 if (names.length === 2) {
220 return resolve(msg("{first} and {second}", { first: names[0], second: names[1] }));
221 }
222 return resolve(
223 msg("{items}, and {last}", {
224 items: names.slice(0, -1).join(", "),
225 last: names[names.length - 1],
226 }),
227 );
228 }
229
230 export interface ProviderUpdateRun {
231 readonly environmentId: EnvironmentId;
232 readonly machineLabel: string;
233 readonly driver: ProviderDriverKind;
234 readonly instanceId: ProviderInstanceId;
235 readonly result: AtomCommandResult<
236 { readonly providers: ReadonlyArray<ServerProvider> },
237 unknown
238 >;
239 }
240
241 export function getProviderUpdateRunOutcome(
242 run: ProviderUpdateRun,
243 resolve: MessageResolver = m,
244 ):
245 | { readonly status: "interrupted" }
246 | { readonly status: "updated"; readonly message: string | null }
247 | { readonly status: "failed"; readonly line: string } {
248 if (isAtomCommandInterrupted(run.result)) return { status: "interrupted" };
249 const label = `${run.machineLabel} · ${PROVIDER_DISPLAY_NAMES[run.driver] ?? run.driver}`;
250 if (run.result._tag === "Failure") {
251 const error = squashAtomCommandFailure(run.result);
252 return {
253 status: "failed",
254 line: `${label}: ${thrownErrorMessage(error, resolve) ?? resolve(msg("Provider update failed."))}`,
255 };
256 }
257 const provider = run.result.value.providers.find(
258 (candidate) => candidate.instanceId === run.instanceId,
259 );
260 const updateState = provider?.updateState;
261 const restartNotice = provider ? getProviderRestartNotice(provider) : null;
262 return updateState?.status === "succeeded"
263 ? { status: "updated", message: restartNotice ? `${label}: ${restartNotice}` : null }
264 : {
265 status: "failed",
266 line: `${label}: ${updateState?.message ?? resolve(msg("Provider update did not finish."))}`,
267 };
268 }
269
270 export function getProviderUpdateRunToastView(
271 runs: ReadonlyArray<ProviderUpdateRun>,
272 resolve: MessageResolver = m,
273 ): {
274 readonly type: "success" | "error";
275 readonly title: string;
276 readonly description: string;
277 } | null {
278 const settled = runs
279 .map((run) => getProviderUpdateRunOutcome(run, resolve))
280 .filter((outcome) => outcome.status !== "interrupted");
281 if (settled.length === 0) {
282 return null;
283 }
284 const failureLines = settled.flatMap((outcome) =>
285 outcome.status === "failed" ? [outcome.line] : [],
286 );
287 const successMessages = [
288 ...new Set(
289 settled.flatMap((outcome) =>
290 outcome.status === "updated" && outcome.message ? [outcome.message] : [],
291 ),
292 ),
293 ];
294 if (failureLines.length === 0) {
295 return {
296 type: "success",
297 title:
298 settled.length === 1
299 ? resolve(msg("Provider updated"))
300 : resolve(
301 msg(
302 "{count, plural, one {{count} providers updated} other {{count} providers updated}}",
303 { count: settled.length },
304 ),
305 ),
306 description:
307 successMessages.join("\n") || getProviderUpdatedDescription(settled.length, resolve),
308 };
309 }
310 return {
311 type: "error",
312 title:
313 failureLines.length < settled.length
314 ? resolve(
315 msg(
316 "{total, plural, one {{failed} of {total} provider updates failed} other {{failed} of {total} provider updates failed}}",
317 {
318 failed: failureLines.length,
319 total: settled.length,
320 },
321 ),
322 )
323 : settled.length === 1
324 ? resolve(msg("Provider update failed"))
325 : resolve(msg("Provider updates failed")),
326 description: [...failureLines, ...successMessages].join("\n"),
327 };
328 }
329
330 function getUpdateFinishedAt(provider: ServerProvider): string | null {
331 return provider.updateState?.finishedAt ?? null;
332 }
333
334 function isRecentTerminalProvider(
335 provider: ServerProvider,
336 visibleAfterIso: string | undefined,
337 ): boolean {
338 const status = provider.updateState?.status;
339 if (status !== "failed" && status !== "unchanged" && status !== "succeeded") {
340 return false;
341 }
342 if (visibleAfterIso === undefined) {
343 return true;
344 }
345 const finishedAt = getUpdateFinishedAt(provider);
346 return finishedAt !== null && finishedAt >= visibleAfterIso;
347 }
348
349 function latestFinishedAtForProviders(providers: ReadonlyArray<ServerProvider>): string | null {
350 return providers.reduce<string | null>((latest, provider) => {
351 const finishedAt = getUpdateFinishedAt(provider);
352 if (finishedAt === null) {
353 return latest;
354 }
355 return latest === null || finishedAt > latest ? finishedAt : latest;
356 }, null);
357 }
358
359 function terminalUpdateKey(provider: ServerProvider): string {
360 return `${provider.updateState?.status}:${provider.driver}:${provider.updateState?.finishedAt ?? "pending"}:${provider.updateState?.message ?? ""}`;
361 }
362
363 function terminalPillIdentity(providers: ReadonlyArray<ServerProvider>) {
364 const dismissKeys = providers.map(terminalUpdateKey).toSorted();
365 return { key: dismissKeys.join("|"), dismissKeys };
366 }
367
368 /** Use each driver's latest finished instance so an older default-instance result cannot hide it. */
369 function latestTerminalProvidersByDriver(providers: ReadonlyArray<ServerProvider>) {
370 const latestProviderByDriver = new Map<ProviderDriverKind, ServerProvider>();
371
372 for (const provider of providers) {
373 const current = latestProviderByDriver.get(provider.driver);
374 if (!current || (getUpdateFinishedAt(provider) ?? "") >= (getUpdateFinishedAt(current) ?? "")) {
375 latestProviderByDriver.set(provider.driver, provider);
376 }
377 }
378
379 return [...latestProviderByDriver.values()];
380 }
381
382 export function getProviderUpdateSidebarPillView(
383 providers: ReadonlyArray<ServerProvider>,
384 options?: ProviderUpdateSidebarPillOptions,
385 resolve: MessageResolver = m,
386 ): ProviderUpdateSidebarPillView | null {
387 // Filter active instances before deduplicating drivers because update state is per instance.
388 const activeProviders = dedupeProvidersByDriver(providers.filter(isProviderUpdateActive));
389 if (activeProviders.length > 0) {
390 const activeProvider = activeProviders[0]!;
391 const activeProviderName =
392 PROVIDER_DISPLAY_NAMES[activeProvider.driver] ?? activeProvider.driver;
393 return {
394 key: `loading:${activeProviders
395 .map((provider) => `${provider.driver}:${provider.updateState?.status ?? "idle"}`)
396 .toSorted()
397 .join("|")}`,
398 tone: "loading",
399 title:
400 activeProviders.length === 1
401 ? resolve(msg("Updating {provider}", { provider: activeProviderName }))
402 : resolve(
403 msg(
404 "{count, plural, one {Updating {count} providers} other {Updating {count} providers}}",
405 { count: activeProviders.length },
406 ),
407 ),
408 description:
409 activeProviders.length === 1
410 ? resolve(
411 msg("{providers} update in progress.", {
412 providers: formatProviderList(activeProviders, resolve),
413 }),
414 )
415 : resolve(
416 msg("{providers} updates are in progress.", {
417 providers: formatProviderList(activeProviders, resolve),
418 }),
419 ),
420 };
421 }
422
423 const recentTerminalProviders = latestTerminalProvidersByDriver(
424 providers.filter((provider) => isRecentTerminalProvider(provider, options?.visibleAfterIso)),
425 ).filter((provider) => !options?.dismissedKeys?.has(terminalUpdateKey(provider)));
426 const terminalCandidates: ProviderUpdateSidebarPillView[] = [];
427
428 const failedProviders = recentTerminalProviders.filter(
429 (provider) => provider.updateState?.status === "failed",
430 );
431 if (failedProviders.length > 0) {
432 const failedProvider = failedProviders[0]!;
433 terminalCandidates.push({
434 ...terminalPillIdentity(failedProviders),
435 tone: "error",
436 title:
437 failedProviders.length === 1
438 ? getProviderFailedUpdateTitle(failedProvider, resolve)
439 : resolve(
440 msg(
441 "{count, plural, one {{count} provider updates failed} other {{count} provider updates failed}}",
442 { count: failedProviders.length },
443 ),
444 ),
445 description: getFailedProviderUpdateDescription(failedProviders, resolve),
446 dismissible: true,
447 });
448 }
449
450 const unchangedProviders = recentTerminalProviders.filter(
451 (provider) => provider.updateState?.status === "unchanged",
452 );
453 if (unchangedProviders.length > 0) {
454 const unchangedProvider = unchangedProviders[0]!;
455 const unchangedProviderName =
456 PROVIDER_DISPLAY_NAMES[unchangedProvider.driver] ?? unchangedProvider.driver;
457 terminalCandidates.push({
458 ...terminalPillIdentity(unchangedProviders),
459 tone: "warning",
460 title:
461 unchangedProviders.length === 1
462 ? resolve(msg("{provider} still needs an update", { provider: unchangedProviderName }))
463 : resolve(
464 msg(
465 "{count, plural, one {{count} providers still need updates} other {{count} providers still need updates}}",
466 { count: unchangedProviders.length },
467 ),
468 ),
469 description:
470 unchangedProviders.length === 1
471 ? resolve(
472 msg("{providers} still appears outdated. Review provider settings for details.", {
473 providers: formatProviderList(unchangedProviders, resolve),
474 }),
475 )
476 : resolve(
477 msg("{providers} still appear outdated. Review provider settings for details.", {
478 providers: formatProviderList(unchangedProviders, resolve),
479 }),
480 ),
481 dismissible: true,
482 });
483 }
484
485 const succeededProviders = recentTerminalProviders.filter(
486 (provider) => provider.updateState?.status === "succeeded",
487 );
488 if (succeededProviders.length > 0) {
489 const succeededProvider = succeededProviders[0]!;
490 terminalCandidates.push({
491 ...terminalPillIdentity(succeededProviders),
492 tone: "success",
493 title:
494 succeededProviders.length === 1
495 ? getProviderUpdatedTitle(succeededProvider, resolve)
496 : resolve(
497 msg(
498 "{count, plural, one {{count} providers updated} other {{count} providers updated}}",
499 { count: succeededProviders.length },
500 ),
501 ),
502 description:
503 [...new Set(succeededProviders.map(getProviderRestartNotice).filter(Boolean))].join("\n") ||
504 getProviderUpdatedDescription(succeededProviders.length, resolve),
505 dismissAfterVisibleMs: PROVIDER_UPDATE_SUCCESS_VISIBLE_MS,
506 });
507 }
508
509 return (
510 terminalCandidates
511 .toSorted((left, right) => {
512 const leftProviders =
513 left.tone === "error"
514 ? failedProviders
515 : left.tone === "warning"
516 ? unchangedProviders
517 : succeededProviders;
518 const rightProviders =
519 right.tone === "error"
520 ? failedProviders
521 : right.tone === "warning"
522 ? unchangedProviders
523 : succeededProviders;
524 const leftFinishedAt = latestFinishedAtForProviders(leftProviders) ?? "";
525 const rightFinishedAt = latestFinishedAtForProviders(rightProviders) ?? "";
526 return rightFinishedAt.localeCompare(leftFinishedAt);
527 })
528 .at(0) ?? null
529 );
530 }
531
532 function getFailedProviderUpdateDescription(
533 providers: ReadonlyArray<ServerProvider>,
534 resolve: MessageResolver,
535 ): string {
536 if (providers.length === 1) {
537 const provider = providers[0]!;
538 if (provider.updateState?.message) {
539 return provider.updateState.message;
540 }
541 }
542 return resolve(
543 msg("{providers} failed to update. Check provider settings for details.", {
544 providers: formatProviderList(providers, resolve),
545 }),
546 );
547 }