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

main
ts 209 lines 6.72 KB
Raw
1 import type {
2 ServerProvider,
3 ServerProviderVersionAdvisory,
4 ServerProviderCompatibilityAdvisory,
5 } from "@t3tools/contracts";
6 import { msg } from "gt-react";
7
8 import { m, type MessageResolver } from "../../i18n/messages";
9
10 export const PROVIDER_STATUS_STYLES = {
11 disabled: {
12 dot: "bg-muted-foreground/50",
13 },
14 error: {
15 dot: "bg-destructive",
16 },
17 neutral: {
18 dot: "bg-muted-foreground",
19 },
20 ready: {
21 dot: "bg-success",
22 },
23 warning: {
24 dot: "bg-warning",
25 },
26 } as const;
27
28 export type ProviderStatusKey = keyof typeof PROVIDER_STATUS_STYLES;
29
30 /** The server names a custom endpoint in English; other auth labels are product or plan names. */
31 export function providerAuthLabel(
32 auth: Pick<ServerProvider["auth"], "label" | "type">,
33 resolve: MessageResolver = m,
34 ): string | undefined {
35 if (auth.type === "customEndpoint") return resolve(msg("Custom API endpoint"));
36 return auth.label ?? auth.type;
37 }
38
39 // Antigravity's local health check verifies installation, not Google sign-in.
40 // API-key and Agent Platform warnings still need attention.
41 function isAntigravitySignInUnchecked(provider: ServerProvider): boolean {
42 return (
43 provider.driver === "antigravity" &&
44 provider.installed &&
45 provider.status === "warning" &&
46 provider.auth.status === "unknown" &&
47 (provider.auth.type === undefined ||
48 provider.auth.type === "oauth-personal" ||
49 provider.auth.type === "oauth-business")
50 );
51 }
52
53 export function getProviderStatusKey(provider: ServerProvider | undefined): ProviderStatusKey {
54 if (provider && !provider.enabled) return "disabled";
55 if (provider && isAntigravitySignInUnchecked(provider)) return "neutral";
56 return provider?.status ?? "warning";
57 }
58
59 export function getProviderSummary(
60 provider: ServerProvider | undefined,
61 resolve: MessageResolver = m,
62 ) {
63 if (!provider) {
64 return {
65 headline: resolve(msg("Checking provider status")),
66 detail: resolve(
67 msg("Waiting for the server to report installation and authentication details."),
68 ),
69 };
70 }
71 if (!provider.enabled || provider.status === "disabled") {
72 return {
73 headline: resolve(msg("Disabled", { $context: "provider status" })),
74 detail:
75 provider.message ??
76 resolve(msg("This provider is installed but disabled for new sessions in T3 Code.")),
77 };
78 }
79 if (!provider.installed) {
80 return {
81 headline: resolve(msg("Not found", { $context: "provider status, CLI is missing" })),
82 detail: provider.message ?? resolve(msg("CLI not detected on PATH.")),
83 };
84 }
85 if (provider.auth.status === "unauthenticated") {
86 const authLabel = providerAuthLabel(provider.auth, resolve);
87 return {
88 headline: authLabel
89 ? resolve(msg("Not authenticated · {method}", { method: authLabel }))
90 : resolve(msg("Not authenticated")),
91 detail: provider.message ?? null,
92 };
93 }
94 if (isAntigravitySignInUnchecked(provider)) {
95 return {
96 headline: resolve(msg("Installed · Sign-in not checked")),
97 detail: provider.message ?? null,
98 };
99 }
100 if (provider.status === "warning") {
101 return {
102 headline: resolve(msg("Needs attention")),
103 detail:
104 provider.message ??
105 resolve(msg("The provider is installed, but the server could not fully verify it.")),
106 };
107 }
108 if (provider.status === "error") {
109 return {
110 headline: resolve(msg("Unavailable", { $context: "provider status" })),
111 detail: provider.message ?? resolve(msg("The provider failed its startup checks.")),
112 };
113 }
114 if (provider.auth.status === "authenticated") {
115 const authLabel = providerAuthLabel(provider.auth, resolve);
116 return {
117 headline: authLabel
118 ? resolve(msg("Authenticated · {method}", { method: authLabel }))
119 : resolve(msg("Authenticated")),
120 detail: provider.message ?? null,
121 };
122 }
123 return {
124 headline: resolve(msg("Available", { $context: "provider status" })),
125 detail: provider.message ?? null,
126 };
127 }
128
129 export function getProviderVersionLabel(version: string | null | undefined) {
130 if (!version) return null;
131 const antigravity = /^agy_acp_server_(\d{4})(\d{2})(\d{2})_\d+(?:_(\w+))?$/.exec(version);
132 if (antigravity) {
133 const [, year, month, day, candidate] = antigravity;
134 return `${year}-${month}-${day}${candidate ? ` ${candidate}` : ""}`;
135 }
136 return /^\d/.test(version) ? `v${version}` : version;
137 }
138
139 const COMPATIBILITY_TITLES = {
140 graceful: msg("Limited support"),
141 unsupported: msg("Unsupported version"),
142 broken: msg("Known broken version"),
143 } as const;
144
145 export function getProviderVersionAdvisoryPresentation(
146 advisory: ServerProviderVersionAdvisory | undefined,
147 compatibility?: ServerProviderCompatibilityAdvisory | undefined,
148 showCompatibility = true,
149 resolve: MessageResolver = m,
150 ): {
151 readonly title: string;
152 readonly detail: string;
153 readonly updateCommand: string | null;
154 readonly emphasis: "normal" | "strong";
155 readonly targetVersion: string | null;
156 } | null {
157 const latestIsIncompatible =
158 compatibility?.latestVersionStatus === "broken" ||
159 compatibility?.latestVersionStatus === "unsupported";
160 if (
161 showCompatibility &&
162 compatibility &&
163 (compatibility.status === "graceful" ||
164 compatibility.status === "unsupported" ||
165 compatibility.status === "broken")
166 ) {
167 const targetVersion = compatibility.recommendedVersion;
168 const recommendation = getProviderVersionLabel(targetVersion) ?? compatibility.recommendedRange;
169 // Latest package versions cannot be updated into recommendations requiring another package.
170 const isAlreadyLatest = advisory?.status === "current";
171 return {
172 title: resolve(COMPATIBILITY_TITLES[compatibility.status]),
173 detail:
174 compatibility.message ??
175 (recommendation
176 ? resolve(msg("Use {version} for full support.", { version: recommendation }))
177 : resolve(msg("Update for full support."))),
178 updateCommand:
179 targetVersion || latestIsIncompatible || isAlreadyLatest
180 ? null
181 : (advisory?.updateCommand ?? null),
182 emphasis: compatibility.status === "graceful" ? "normal" : "strong",
183 targetVersion,
184 };
185 }
186 if (
187 !advisory ||
188 advisory.status === "current" ||
189 advisory.status === "unknown" ||
190 latestIsIncompatible
191 ) {
192 return null;
193 }
194
195 const version = advisory.latestVersion;
196 const versionLabel = getProviderVersionLabel(version);
197
198 return {
199 title: resolve(msg("Update available")),
200 detail:
201 advisory.message ??
202 (versionLabel
203 ? resolve(msg("Update available: install {version}.", { version: versionLabel }))
204 : resolve(msg("Update available: install the latest provider version."))),
205 updateCommand: advisory.updateCommand,
206 emphasis: "normal" as const,
207 targetVersion: null,
208 };
209 }