Skip to content
Source
Sign inSign up
pingdotgg/t3code
Open History to see the last commit

presentation.ts

150 lines5.2 KB

1import type { ServerConfig } from "@t3tools/contracts";
2import * as Option from "effect/Option";
3​
4import type { ConnectionCatalogEntry } from "./catalog.ts";
5import type { ConnectionTarget, SupervisorConnectionState } from "./model.ts";
6import { connectionRouteId, connectionRoutes, routeHttpBaseUrl } from "./routes.ts";
7​
8export type EnvironmentConnectionPhase =
9 | "available"
10 | "offline"
11 | "connecting"
12 | "reconnecting"
13 | "connected"
14 | "error"
15 | "unsupported";
16​
17export interface EnvironmentConnectionPresentation {
18 readonly phase: EnvironmentConnectionPhase;
19 readonly error: string | null;
20 readonly traceId: string | null;
22​
23/**
24 * Provider statuses are pushed every few minutes with fresh `checkedAt` stamps, and every root
25 * coordinator reads environment presentations. Leaving them out keeps a presentation stable
26 * across those pushes; provider readers subscribe to the server's providers atom instead.
27 */
28export type EnvironmentServerConfig = Omit<ServerConfig, "providers">;
29​
30export interface EnvironmentPresentation {
31 readonly entry: ConnectionCatalogEntry;
32 readonly connection: EnvironmentConnectionPresentation;
33 readonly serverConfig: EnvironmentServerConfig | null;
35​
36export function presentConnectionState(
37 state: SupervisorConnectionState,
38): EnvironmentConnectionPresentation {
39 switch (state.phase) {
40 case "available":
41 return { phase: "available", error: null, traceId: null };
42 case "offline":
43 return { phase: "offline", error: null, traceId: null };
44 case "connecting":
45 return {
46 phase: state.attempt <= 1 && state.lastFailure === null ? "connecting" : "reconnecting",
47 error: state.lastFailure?.message ?? null,
48 traceId: state.lastFailure?.traceId ?? null,
49 };
50 case "connected":
51 return { phase: "connected", error: null, traceId: null };
52 case "backoff":
53 return {
54 phase: "reconnecting",
55 error: state.lastFailure?.message ?? null,
56 traceId: state.lastFailure?.traceId ?? null,
57 };
58 case "blocked":
59 return {
60 phase: state.lastFailure?.reason === "unsupported" ? "unsupported" : "error",
61 error: state.lastFailure?.message ?? null,
62 traceId: state.lastFailure?.traceId ?? null,
63 };
64 }
66​
67export function connectionStatusText(connection: EnvironmentConnectionPresentation): string {
68 switch (connection.phase) {
69 case "available":
70 return "Available";
71 case "offline":
72 return "Offline";
73 case "connecting":
74 return "Connecting...";
75 case "reconnecting":
76 return connection.error
77 ? `Failed to connect. Reconnecting... Reason: ${connection.error}`
78 : "Reconnecting...";
79 case "connected":
80 return "Connected";
81 case "unsupported":
82 return "Client not supported";
83 case "error":
84 return connection.error
85 ? `Connection failed. Reason: ${connection.error}`
86 : "Connection failed";
87 }
89​
90export function connectionStatusTitle(connection: EnvironmentConnectionPresentation): string {
91 if (connection.phase === "reconnecting" && connection.error) {
92 return "Failed to connect. Reconnecting...";
93 }
94 return connectionStatusText({ ...connection, error: null });
96​
97/**
98 * The T3 Connect address wins whenever it is known: it works for agents anywhere, while the
99 * connected route is often a LAN or loopback address. SSH routes ride a local forward that
100 * disappears with the client, so they have no stable address.
101 */
102export function environmentMcpUrl(input: {
103 readonly entry: ConnectionCatalogEntry;
104 readonly relayHttpBaseUrl?: string | undefined;
105 readonly connectedTarget?: ConnectionTarget | null | undefined;
106}): string | null {
107 const relayMcpUrl = input.relayHttpBaseUrl ? mcpUrlFromBase(input.relayHttpBaseUrl) : null;
108 if (relayMcpUrl !== null) return relayMcpUrl;
109 const connectedRouteId = input.connectedTarget ? connectionRouteId(input.connectedTarget) : null;
110 const routes = connectionRoutes(input.entry);
111 const connectedRoute = routes.find(
112 (route) => connectionRouteId(route.target) === connectedRouteId,
113 );
114 for (const route of connectedRoute ? [connectedRoute, ...routes] : routes) {
115 const httpBaseUrl = routeHttpBaseUrl(route);
116 const mcpUrl = httpBaseUrl === null ? null : mcpUrlFromBase(httpBaseUrl);
117 if (mcpUrl !== null) return mcpUrl;
118 }
119 return null;
121​
122function mcpUrlFromBase(httpBaseUrl: string): string | null {
123 let url: URL;
124 try {
125 url = new URL(httpBaseUrl);
126 } catch {
127 return null;
128 }
129 url.pathname = "/mcp";
130 url.search = "";
131 url.hash = "";
132 return url.toString();
134​
135export function connectionCatalogDisplayUrl(entry: ConnectionCatalogEntry): string | null {
136 switch (entry.target._tag) {
137 case "PrimaryConnectionTarget":
138 return entry.target.httpBaseUrl;
139 case "RelayConnectionTarget":
140 return null;
141 case "BearerConnectionTarget":
142 return Option.isSome(entry.profile) && entry.profile.value._tag === "BearerConnectionProfile"
143 ? entry.profile.value.httpBaseUrl
144 : null;
145 case "SshConnectionTarget":
146 return Option.isSome(entry.profile) && entry.profile.value._tag === "SshConnectionProfile"
147 ? `${entry.profile.value.target.username}@${entry.profile.value.target.hostname}`
148 : null;
149 }