@devries-cameron20 / t3code Mirror · read-only / commits / 69ceea9dc6
Fork 0

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 22, 23:15 UTC

fix(server): T3 Connect links from the desktop app when the backend runs in WSL (#19271)

Co-authored-by: Claude Opus 5.5 <noreply@anthropic.com> Co-authored-by: Julius Marminge <julius0216@outlook.com>

Aidid Haiqal committed Oct 20, 2026 at 12:40 UTC 69ceea9dc6b4e758e3998bded7cae1535449bbfa
3 files changed +276 -6
apps/server/src/cloud/CloudLink.ts
+16 -4
@@ -2,6 +2,7 @@
2 import * as NodeCrypto from "node:crypto";
3 import {
4 AuthStandardClientScopes,
5 + EnvironmentAuthenticatedPrincipal,
6 type EnvironmentCloudLinkStateResult,
7 type EnvironmentCloudPreferencesRequest,
8 type EnvironmentCloudRelayConfigResult,
@@ -417,14 +418,18 @@ export class CloudLink extends Context.Service<
418 {
419 /**
420 * Signs the proof the relay asks for to link this environment. The request
420 - * must reach this server directly on the loopback origin it names.
421 + * must reach this server directly. Desktop bootstrap sessions may use the
422 + * WSL IP; all other sessions must use the loopback origin they name.
423 */
424 readonly linkProof: (
425 request: RelayLinkProofRequest,
426 httpRequest: HttpServerRequest.HttpServerRequest,
427 ) => Effect.Effect<
428 RelayEnvironmentLinkProof,
427 - CloudLinkOriginInvalidError | CloudLinkInternalError | EnvironmentAuth.ServerAuthInternalError
429 + | CloudLinkOriginInvalidError
430 + | CloudLinkInternalError
431 + | EnvironmentAuth.ServerAuthInternalError,
432 + EnvironmentAuthenticatedPrincipal
433 >;
434 readonly applyRelayConfig: (
435 payload: RelayEnvironmentConfigRequest,
@@ -580,6 +585,7 @@ const make = Effect.gen(function* () {
585 const makeCloudLinkProof = Effect.fn("environment.cloud.makeLinkProof")(function* (
586 request: RelayLinkProofRequest,
587 requestUrl: string,
588 + allowNonLoopbackRequestHost = false,
589 ) {
590 const keyPair = yield* getOrCreateEnvironmentKeyPairFromSecretStore(secrets);
591 if (
@@ -587,6 +593,7 @@ const make = Effect.gen(function* () {
593 !isAllowedEndpointOrigin({
594 origin: request.origin,
595 requestUrl,
596 + allowNonLoopbackRequestHost,
597 })
598 ) {
599 return yield* new CloudLinkOriginInvalidError({ origin: "endpoint" });
@@ -630,8 +637,13 @@ const make = Effect.gen(function* () {
637 if (requestUrl === null || hasForwardedAuthorityHeaders(httpRequest)) {
638 return yield* new CloudLinkOriginInvalidError({ origin: "endpoint" });
639 }
633 - const proof = yield* makeCloudLinkProof(request, requestUrl);
634 - return proof satisfies RelayEnvironmentLinkProof;
640 + const principal = yield* EnvironmentAuthenticatedPrincipal;
641 + // WSL desktop requests use the distro IP; only the server-issued bootstrap subject qualifies.
642 + return yield* makeCloudLinkProof(
643 + request,
644 + requestUrl,
645 + principal.subject === "desktop-bootstrap",
646 + );
647 },
648 Effect.catchIf(ServerSecretStore.isSecretStoreError, internalError("generate-link-proof")),
649 Effect.catchTags({ PlatformError: internalError("generate-link-proof") }),
apps/server/src/cloud/http.test.ts
+258 -1
@@ -1,18 +1,275 @@
1 import * as NodeServices from "@effect/platform-node/NodeServices";
2 -import { EnvironmentHttpApi } from "@t3tools/contracts";
2 import { describe, expect, it } from "@effect/vitest";
3 +import {
4 + AuthAccessTokenType,
5 + AuthEnvironmentBootstrapTokenType,
6 + AuthTokenExchangeGrantType,
7 + EnvironmentHttpApi,
8 + EnvironmentId,
9 +} from "@t3tools/contracts";
10 +import {
11 + RelayEnvironmentLinkProofPayload,
12 + type RelayLinkProofRequest,
13 +} from "@t3tools/contracts/relay";
14 import * as Effect from "effect/Effect";
15 import * as Layer from "effect/Layer";
16 +import * as Schema from "effect/Schema";
17 +import { HttpClient, HttpServer } from "effect/http";
18 import * as Etag from "effect/http/Etag";
19 import * as HttpPlatform from "effect/http/HttpPlatform";
20 import * as HttpRouter from "effect/http/HttpRouter";
21 import * as HttpApi from "effect/http-api/HttpApi";
22 import * as HttpApiBuilder from "effect/http-api/HttpApiBuilder";
23 +import * as NetAddress from "effect/net/NetAddress";
24 +import { decodeJwt, importSPKI, jwtVerify } from "jose";
25 +import { RELAY_LINK_PROOF_TYP } from "@t3tools/shared/relayJwt";
26
27 import * as EnvironmentAuth from "../auth/EnvironmentAuth.ts";
28 import * as AuthHttp from "../auth/http.ts";
29 +import * as ServerSecretStore from "../auth/ServerSecretStore.ts";
30 +import * as ServerConfig from "../config.ts";
31 +import * as ServerEnvironment from "../environment/ServerEnvironment.ts";
32 +import * as SqlitePersistence from "../persistence/Sqlite.ts";
33 +import * as AgentAwarenessRelay from "../relay/AgentAwarenessRelay.ts";
34 +import * as CliTokenManager from "./CliTokenManager.ts";
35 import * as CloudLink from "./CloudLink.ts";
36 import * as ConnectHttp from "./http.ts";
37 +import * as ManagedEndpointRuntime from "./ManagedEndpointRuntime.ts";
38 +
39 +const DESKTOP_BOOTSTRAP_TOKEN = "test-desktop-bootstrap-token";
40 +const NON_LOOPBACK_ORIGIN = "http://172.24.162.233:3773";
41 +const LOOPBACK_ORIGIN = "http://127.0.0.1:3773";
42 +const proofRequest: RelayLinkProofRequest = {
43 + challenge: "test-challenge",
44 + relayIssuer: "https://relay.example.test",
45 + endpoint: {
46 + providerKind: "cloudflare_tunnel",
47 + httpBaseUrl: "https://environment.example.test",
48 + wsBaseUrl: "wss://environment.example.test",
49 + },
50 + origin: { localHttpHost: "127.0.0.1", localHttpPort: 3773 },
51 +};
52 +const decodeLinkProofPayload = Schema.decodeUnknownSync(RelayEnvironmentLinkProofPayload);
53 +
54 +class LinkProofTestApi extends HttpApi.make("environment").add(
55 + EnvironmentHttpApi.groups.auth,
56 + EnvironmentHttpApi.groups.connect,
57 +) {}
58 +
59 +const layerConfig = Layer.effect(
60 + ServerConfig.ServerConfig,
61 + Effect.gen(function* () {
62 + const config = yield* ServerConfig.ServerConfig;
63 + return {
64 + ...config,
65 + mode: "desktop" as const,
66 + host: "0.0.0.0",
67 + port: 3773,
68 + desktopBootstrapToken: DESKTOP_BOOTSTRAP_TOKEN,
69 + };
70 + }),
71 +).pipe(Layer.provide(ServerConfig.layerTest(process.cwd(), { prefix: "t3-link-proof-test-" })));
72 +
73 +// Real credential issuance, verification, origin checks and signing; no relay or tunnel is started.
74 +const layerLinkProofRoutes = HttpApiBuilder.layer(LinkProofTestApi).pipe(
75 + Layer.provide([AuthHttp.layer, ConnectHttp.layer]),
76 + Layer.provide(AuthHttp.layerAuthenticatedAuth),
77 + Layer.provide(CloudLink.layer),
78 + Layer.provide(EnvironmentAuth.layer),
79 + Layer.provide([
80 + SqlitePersistence.layerMemory,
81 + ServerEnvironment.layerIdentity,
82 + Layer.mock(ServerEnvironment.ServerEnvironment)({
83 + getDescriptor: Effect.succeed({
84 + environmentId: EnvironmentId.make("wsl-environment"),
85 + label: "WSL",
86 + platform: { os: "linux", arch: "x64" },
87 + serverVersion: "0.0.0-test",
88 + capabilities: { repositoryIdentity: false },
89 + }),
90 + }),
91 + Layer.mock(ManagedEndpointRuntime.CloudManagedEndpointRuntime)({}),
92 + Layer.mock(CliTokenManager.CloudCliTokenManager)({}),
93 + Layer.mock(AgentAwarenessRelay.AgentAwarenessRelay)({}),
94 + Layer.mock(HttpServer.HttpServer)({
95 + address: NetAddress.inetAddressFromIpStringUnsafe("0.0.0.0", 3773),
96 + }),
97 + Layer.succeed(
98 + HttpClient.HttpClient,
99 + HttpClient.make(() => Effect.die("Unexpected relay call")),
100 + ),
101 + ]),
102 + Layer.provideMerge(ServerSecretStore.layer),
103 + Layer.provide(layerConfig),
104 + Layer.provideMerge(HttpPlatform.layer.pipe(Layer.provideMerge(Etag.layerWeak))),
105 + Layer.provideMerge(NodeServices.layer),
106 +);
107 +
108 +const withLinkProofClient = async (
109 + body: (client: {
110 + post: (
111 + path: string,
112 + payload: unknown,
113 + headers?: Record<string, string>,
114 + origin?: string,
115 + ) => Promise<Response>;
116 + exchange: (credential: string, scope?: string) => Promise<string>;
117 + }) => Promise<void>,
118 +) => {
119 + const { handler, dispose } = HttpRouter.toWebHandler(layerLinkProofRoutes, {
120 + disableLogger: true,
121 + });
122 + const post = (
123 + path: string,
124 + payload: unknown,
125 + headers?: Record<string, string>,
126 + origin = NON_LOOPBACK_ORIGIN,
127 + ) =>
128 + handler(
129 + new Request(`${origin}${path}`, {
130 + method: "POST",
131 + headers: { "content-type": "application/json", ...headers },
132 + body: JSON.stringify(payload),
133 + }),
134 + );
135 + const exchange = async (credential: string, scope?: string) => {
136 + const response = await handler(
137 + new Request(`${NON_LOOPBACK_ORIGIN}/oauth/token`, {
138 + method: "POST",
139 + body: new URLSearchParams({
140 + grant_type: AuthTokenExchangeGrantType,
141 + subject_token: credential,
142 + subject_token_type: AuthEnvironmentBootstrapTokenType,
143 + requested_token_type: AuthAccessTokenType,
144 + ...(scope ? { scope } : {}),
145 + }),
146 + }),
147 + );
148 + expect(response.status).toBe(200);
149 + const payload = (await response.json()) as { access_token: string };
150 + return payload.access_token;
151 + };
152 + try {
153 + await body({ post, exchange });
154 + } finally {
155 + await dispose();
156 + }
157 +};
158 +
159 +describe("link proof over a non-loopback desktop transport", () => {
160 + it("signs a loopback tunnel origin after desktop bootstrap token exchange over a non-loopback host", () =>
161 + withLinkProofClient(async ({ post, exchange }) => {
162 + const token = await exchange(DESKTOP_BOOTSTRAP_TOKEN);
163 + const response = await post("/api/connect/link-proof", proofRequest, {
164 + authorization: `Bearer ${token}`,
165 + });
166 + expect(response.status).toBe(200);
167 + const proof = (await response.json()) as string;
168 + const payload = decodeLinkProofPayload(decodeJwt(proof));
169 + const verified = await jwtVerify(
170 + proof,
171 + await importSPKI(payload.environmentPublicKey, "EdDSA"),
172 + {
173 + algorithms: ["EdDSA"],
174 + typ: RELAY_LINK_PROOF_TYP,
175 + issuer: "t3-env:wsl-environment",
176 + audience: proofRequest.relayIssuer,
177 + },
178 + );
179 + expect(verified.payload).toMatchObject({
180 + origin: proofRequest.origin,
181 + endpoint: proofRequest.endpoint,
182 + challenge: proofRequest.challenge,
183 + });
184 + expect(response.headers.get("cache-control")).toBe("no-store");
185 + }));
186 +
187 + it("does not pass desktop trust to a paired client or accept client-supplied provenance", () =>
188 + withLinkProofClient(async ({ post, exchange }) => {
189 + const desktop = await exchange(DESKTOP_BOOTSTRAP_TOKEN);
190 + const paired = await post(
191 + "/api/auth/pairing-token",
192 + {
193 + scopes: ["relay:write"],
194 + label: "desktop-bootstrap",
195 + subject: "desktop-bootstrap",
196 + },
197 + { authorization: `Bearer ${desktop}` },
198 + );
199 + expect(paired.status).toBe(200);
200 + const { credential } = (await paired.json()) as { credential: string };
201 + const token = await exchange(credential);
202 + const headers = { authorization: `Bearer ${token}`, "x-desktop-bootstrap": "true" };
203 + const payload = {
204 + ...proofRequest,
205 + allowNonLoopbackRequestHost: true,
206 + subject: "desktop-bootstrap",
207 + };
208 + const rejected = await post("/api/connect/link-proof", payload, headers);
209 + expect(rejected.status).toBe(400);
210 + expect(await rejected.json()).toMatchObject({ message: "Invalid managed endpoint origin." });
211 + const loopback = await post(
212 + "/api/connect/link-proof",
213 + proofRequest,
214 + headers,
215 + LOOPBACK_ORIGIN,
216 + );
217 + expect(loopback.status).toBe(200);
218 + }));
219 +
220 + it.each([
221 + {
222 + name: "non-loopback tunnel origin",
223 + origin: { localHttpHost: "172.24.162.233", localHttpPort: 3773 },
224 + headers: {},
225 + },
226 + {
227 + name: "mismatched port",
228 + origin: { localHttpHost: "127.0.0.1", localHttpPort: 3774 },
229 + headers: {},
230 + },
231 + {
232 + name: "forwarded host",
233 + origin: proofRequest.origin,
234 + headers: { "x-forwarded-host": "127.0.0.1:3773" },
235 + },
236 + {
237 + name: "forwarded protocol",
238 + origin: proofRequest.origin,
239 + headers: { "x-forwarded-proto": "http" },
240 + },
241 + ])("rejects $name even for desktop bootstrap", ({ origin, headers }) =>
242 + withLinkProofClient(async ({ post, exchange }) => {
243 + const token = await exchange(DESKTOP_BOOTSTRAP_TOKEN);
244 + const response = await post(
245 + "/api/connect/link-proof",
246 + { ...proofRequest, origin },
247 + { ...headers, authorization: `Bearer ${token}` },
248 + );
249 + expect(response.status).toBe(400);
250 + expect(await response.json()).toMatchObject({ message: "Invalid managed endpoint origin." });
251 + }),
252 + );
253 +
254 + it("requires relay-write scope even for desktop bootstrap", () =>
255 + withLinkProofClient(async ({ post, exchange }) => {
256 + const token = await exchange(DESKTOP_BOOTSTRAP_TOKEN, "relay:read");
257 + const response = await post("/api/connect/link-proof", proofRequest, {
258 + authorization: `Bearer ${token}`,
259 + });
260 + expect(response.status).toBe(403);
261 + expect(await response.json()).toMatchObject({
262 + code: "insufficient_scope",
263 + requiredScope: "relay:write",
264 + });
265 + }));
266 +
267 + it("rejects unauthenticated requests", () =>
268 + withLinkProofClient(async ({ post }) => {
269 + const response = await post("/api/connect/link-proof", proofRequest);
270 + expect(response.status).toBe(401);
271 + }));
272 +});
273
274 class ConnectTestApi extends HttpApi.make("environment").add(EnvironmentHttpApi.groups.connect) {}
275
apps/server/src/cloud/linkChecks.ts
+2 -1
@@ -82,13 +82,14 @@ export function parseManagedEndpointLocalOrigin(localOrigin: string) {
82 export function isAllowedEndpointOrigin(input: {
83 readonly origin: RelayManagedEndpointOrigin;
84 readonly requestUrl: string;
85 + readonly allowNonLoopbackRequestHost?: boolean;
86 }): boolean {
87 if (!isLoopbackHostname(input.origin.localHttpHost)) {
88 return false;
89 }
90
91 const url = new URL(input.requestUrl);
91 - if (!isLoopbackHostname(url.hostname)) {
92 + if (!input.allowNonLoopbackRequestHost && !isLoopbackHostname(url.hostname)) {
93 return false;
94 }
95