The best way to control Claude Code, Codex and more from any computer or phone
Mirrored from https://github.com/Camo67/t3code.git
Synced Nov 21, 04:45 UTC
| 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 | } |