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

main
ts 205 lines 5.82 KB
Raw
1 import { EnvironmentId } from "@t3tools/contracts";
2 import { describe, expect, it } from "@effect/vitest";
3 import * as Option from "effect/Option";
4
5 import {
6 BearerConnectionProfile,
7 type ConnectionCatalogEntry,
8 type ConnectionRoute,
9 } from "./catalog.ts";
10 import {
11 BearerConnectionTarget,
12 ConnectionTransientError,
13 RelayConnectionTarget,
14 type SupervisorConnectionState,
15 } from "./model.ts";
16 import {
17 connectionStatusText,
18 connectionStatusTitle,
19 environmentMcpUrl,
20 presentConnectionState,
21 } from "./presentation.ts";
22
23 const TARGET = new BearerConnectionTarget({
24 environmentId: EnvironmentId.make("environment-1"),
25 label: "Remote environment",
26 connectionId: "connection-1",
27 });
28
29 const ENTRY: ConnectionCatalogEntry = {
30 target: TARGET,
31 profile: Option.some(
32 new BearerConnectionProfile({
33 connectionId: TARGET.connectionId,
34 environmentId: TARGET.environmentId,
35 label: TARGET.label,
36 httpBaseUrl: "https://environment.example.test",
37 wsBaseUrl: "wss://environment.example.test",
38 }),
39 ),
40 enabled: true,
41 };
42
43 function supervisorState(overrides: Partial<SupervisorConnectionState>): SupervisorConnectionState {
44 return {
45 desired: true,
46 network: "online",
47 phase: "connecting",
48 stage: "preparing",
49 attempt: 1,
50 generation: 0,
51 lastFailure: null,
52 retryAt: null,
53 refusedRouteIds: [],
54 ...overrides,
55 };
56 }
57
58 describe("connection presentation", () => {
59 it("copies the T3 Connect MCP address first, then the route this device is connected over", () => {
60 const route = (connectionId: string, httpBaseUrl: string): ConnectionRoute => {
61 const target = new BearerConnectionTarget({ ...TARGET, connectionId });
62 return {
63 target,
64 profile: Option.some(
65 new BearerConnectionProfile({
66 connectionId,
67 environmentId: TARGET.environmentId,
68 label: TARGET.label,
69 httpBaseUrl,
70 wsBaseUrl: httpBaseUrl.replace(/^http/, "ws"),
71 }),
72 ),
73 };
74 };
75 const lan = route("lan", "http://192.168.4.53:3773/");
76 const tailnet = route("tailnet", "http://100.115.1.44:3773/");
77 const serve = route("serve", "https://machine.tailnet.ts.net/");
78 const entry: ConnectionCatalogEntry = {
79 ...ENTRY,
80 target: lan.target,
81 profile: lan.profile,
82 alternateRoutes: [tailnet, serve],
83 };
84
85 expect(environmentMcpUrl({ entry, connectedTarget: tailnet.target })).toBe(
86 "http://100.115.1.44:3773/mcp",
87 );
88 expect(environmentMcpUrl({ entry })).toBe("http://192.168.4.53:3773/mcp");
89 expect(
90 environmentMcpUrl({
91 entry,
92 connectedTarget: lan.target,
93 relayHttpBaseUrl: "https://tunnel.example.test",
94 }),
95 ).toBe("https://tunnel.example.test/mcp");
96 });
97
98 // regression: #16909 Copy MCP URL falls back to an alternate route when the relay route has no address
99 it("passes over routes without an address of their own", () => {
100 const relay = new RelayConnectionTarget({
101 environmentId: TARGET.environmentId,
102 label: TARGET.label,
103 });
104 const entry: ConnectionCatalogEntry = {
105 ...ENTRY,
106 target: relay,
107 profile: Option.none(),
108 alternateRoutes: [{ target: ENTRY.target, profile: ENTRY.profile }],
109 };
110
111 expect(environmentMcpUrl({ entry, connectedTarget: relay })).toBe(
112 "https://environment.example.test/mcp",
113 );
114 expect(
115 environmentMcpUrl({
116 entry,
117 connectedTarget: relay,
118 relayHttpBaseUrl: "https://tunnel.example.test",
119 }),
120 ).toBe("https://tunnel.example.test/mcp");
121 });
122
123 it("distinguishes initial connection, reconnect, and retry errors", () => {
124 expect(presentConnectionState(supervisorState({ phase: "connecting", attempt: 1 }))).toEqual({
125 phase: "connecting",
126 error: null,
127 traceId: null,
128 });
129 expect(
130 presentConnectionState(
131 supervisorState({
132 phase: "connecting",
133 attempt: 2,
134 lastFailure: new ConnectionTransientError({
135 reason: "transport",
136 detail: "Socket closed.",
137 traceId: "trace-previous",
138 }),
139 }),
140 ),
141 ).toEqual({
142 phase: "reconnecting",
143 error: "Socket closed.",
144 traceId: "trace-previous",
145 });
146 expect(
147 presentConnectionState(
148 supervisorState({
149 phase: "backoff",
150 attempt: 2,
151 retryAt: 1,
152 lastFailure: new ConnectionTransientError({
153 reason: "transport",
154 detail: "Disconnected.",
155 traceId: "trace-1",
156 }),
157 }),
158 ),
159 ).toEqual({
160 phase: "reconnecting",
161 error: "Disconnected.",
162 traceId: "trace-1",
163 });
164 const awaitingApproval = presentConnectionState(
165 supervisorState({
166 phase: "backoff",
167 attempt: 1,
168 retryAt: 1,
169 lastFailure: new ConnectionTransientError({
170 reason: "approval-pending",
171 detail: "Approve this device on Mac mini. It shows code K7QM-2XFD.",
172 traceId: "trace-2",
173 }),
174 }),
175 );
176 expect(awaitingApproval).toEqual({
177 phase: "reconnecting",
178 error: "Approve this device on Mac mini. It shows code K7QM-2XFD.",
179 traceId: "trace-2",
180 awaitingApproval: true,
181 });
182 expect(connectionStatusText(awaitingApproval)).toBe(
183 "Approve this device on Mac mini. It shows code K7QM-2XFD.",
184 );
185 expect(connectionStatusTitle(awaitingApproval)).toBe("Waiting for approval");
186 });
187
188 it("preserves an explicitly available environment while offline", () => {
189 expect(
190 presentConnectionState(
191 supervisorState({
192 desired: false,
193 network: "offline",
194 phase: "available",
195 stage: null,
196 attempt: 0,
197 }),
198 ),
199 ).toEqual({
200 phase: "available",
201 error: null,
202 traceId: null,
203 });
204 });
205 });