The best way to control Claude Code, Codex and more from any computer or phone
fix(client-runtime): a stalled sign-in token or dead route no longer holds a reconnect for 40 seconds (#34623)
Co-authored-by: Claude Fable 5.2 <noreply@anthropic.com>
Julius Marminge committed
Nov 12, 2026 at 08:51 UTC
7c22095fcc7ad6b9324da9730960c38c5af53e90
4 files changed
+105
-20
packages/client-runtime/src/connection/driver.ts
+7
-7
@@ -116,16 +116,16 @@ export const connectOverRoutes = Effect.fn("ConnectionDriver.connectOverRoutes")
116
// An incompatible server is the same server on every route.
117
if (result.failure.reason === "unsupported") return yield* result.failure;
118
}
119
- // A slow route that answered after the head start goes before one that is
120
- // still dead, which can hold an attempt open far longer than its probe.
119
const late = yield* Effect.forEach(silent, ({ index }) => Fiber.join(checks[index]!), {
120
concurrency: "unbounded",
121
});
124
- const retry = [
125
- ...silent.filter((_, position) => late[position] !== "silent"),
126
- ...silent.filter((_, position) => late[position] === "silent"),
127
- ];
128
- for (const { route } of retry) {
122
+ const answeredLate = silent.filter((_, position) => late[position] !== "silent");
123
+ const stillSilent = silent.filter((_, position) => late[position] === "silent");
124
+ for (const { route } of [...answeredLate, ...stillSilent]) {
125
+ // A route still silent after its whole check can hold the attempt open far
126
+ // longer than the check did. Once another route failed in a way that
127
+ // retries, the retry reaches it sooner than waiting here would.
128
+ if (transient !== undefined && stillSilent.some((entry) => entry.route === route)) break;
129
const result = yield* attempt(route);
130
if (result._tag === "Success") return result.success;
131
if (result.failure.reason === "unsupported") return yield* result.failure;
packages/client-runtime/src/connection/supervisor.test.ts
+30
@@ -1871,6 +1871,36 @@ describe("EnvironmentSupervisor routes", () => {
1871
}).pipe(Effect.provide(TestClock.layer())),
1872
);
1873
1874
+ it.effect("retries instead of waiting on a LAN route that stayed silent after relay failed", () =>
1875
+ Effect.gen(function* () {
1876
+ const checkingLan = yield* Deferred.make<void>();
1877
+ const attempted: string[] = [];
1878
+ const harness = yield* makeHarness({
1879
+ checkRoute: (route) =>
1880
+ route.target._tag === "BearerConnectionTarget"
1881
+ ? Deferred.succeed(checkingLan, undefined).pipe(
1882
+ Effect.andThen(Effect.sleep("2500 millis")),
1883
+ Effect.as("silent" as const),
1884
+ )
1885
+ : Effect.succeed("unchecked"),
1886
+ prepare: (_attempt, target) => {
1887
+ attempted.push(target._tag);
1888
+ return target._tag === "RelayConnectionTarget"
1889
+ ? Effect.fail(transient("Relay socket closed."))
1890
+ : Effect.never;
1891
+ },
1892
+ });
1893
+ const supervisor = yield* EnvironmentSupervisor.make(LAN_THEN_RELAY_ENTRY, {
1894
+ initiallyDesired: true,
1895
+ }).pipe(Effect.provide(harness.dependencies));
1896
+
1897
+ yield* Deferred.await(checkingLan);
1898
+ yield* TestClock.adjust("2500 millis");
1899
+ yield* awaitState(supervisor.state, (state) => state.phase === "backoff");
1900
+ expect(attempted).toEqual(["RelayConnectionTarget"]);
1901
+ }).pipe(Effect.provide(TestClock.layer())),
1902
+ );
1903
+
1904
it.effect("skips a silent LAN route and connects over T3 Connect", () =>
1905
Effect.gen(function* () {
1906
const harness = yield* makeHarness({
packages/client-runtime/src/relay/managedRelayState.test.ts
+37
@@ -8,6 +8,7 @@ import * as Effect from "effect/Effect";
8
import * as Fiber from "effect/Fiber";
9
import * as Layer from "effect/Layer";
10
import * as Logger from "effect/Logger";
11
+import * as TestClock from "effect/testing/TestClock";
12
import { Atom, AtomRegistry } from "effect/reactivity";
13
import { afterEach, vi } from "vite-plus/test";
14
@@ -191,6 +192,42 @@ describe("createManagedRelayQueryManager", () => {
192
}),
193
);
194
195
+ it.effect("replaces a Clerk token read that has not answered after 4 seconds", () =>
196
+ Effect.gen(function* () {
197
+ const token = clerkToken(4_102_444_800);
198
+ const readClerkToken = vi
199
+ .fn<() => Promise<string | null>>()
200
+ .mockReturnValueOnce(new Promise(() => {}))
201
+ .mockResolvedValue(token);
202
+ const session = createManagedRelaySession({ accountId: "account-1", readClerkToken });
203
+
204
+ const readsFiber = yield* Effect.all([session.readClerkToken(), session.readClerkToken()], {
205
+ concurrency: "unbounded",
206
+ }).pipe(Effect.forkChild);
207
+ yield* TestClock.adjust("3999 millis");
208
+ expect(readClerkToken).toHaveBeenCalledTimes(1);
209
+
210
+ yield* TestClock.adjust("1 millis");
211
+ expect(yield* Fiber.join(readsFiber)).toEqual([token, token]);
212
+ expect(readClerkToken).toHaveBeenCalledTimes(2);
213
+ }),
214
+ );
215
+
216
+ it.effect("fails a Clerk token read that never answers after three tries", () =>
217
+ Effect.gen(function* () {
218
+ const readClerkToken = vi.fn(() => new Promise<string | null>(() => {}));
219
+ const session = createManagedRelaySession({ accountId: "account-1", readClerkToken });
220
+
221
+ const readFiber = yield* session.readClerkToken().pipe(Effect.flip, Effect.forkChild);
222
+ yield* TestClock.adjust("12 seconds");
223
+
224
+ expect((yield* Fiber.join(readFiber)).message).toBe(
225
+ "Timed out obtaining the T3 Connect session token.",
226
+ );
227
+ expect(readClerkToken).toHaveBeenCalledTimes(3);
228
+ }),
229
+ );
230
+
231
it.effect("updates the token provider without replacing a same-account session", () =>
232
Effect.gen(function* () {
233
const firstRead = vi.fn(() => Promise.resolve<string | null>(null));
packages/client-runtime/src/relay/managedRelayState.ts
+31
-13
@@ -3,6 +3,7 @@ import { decodeRelayJwt } from "@t3tools/shared/relayJwt";
3
import * as Cause from "effect/Cause";
4
import * as Clock from "effect/Clock";
5
import * as Effect from "effect/Effect";
6
+import * as Option from "effect/Option";
7
import * as Schema from "effect/Schema";
8
import * as Stream from "effect/Stream";
9
import { AsyncResult, Atom, AtomRegistry } from "effect/reactivity";
@@ -14,6 +15,11 @@ import { relayProtectedErrorMessage } from "./errorPresentation.ts";
15
const DEFAULT_STALE_TIME_MS = 15_000;
16
const DEFAULT_IDLE_TTL_MS = 5 * 60_000;
17
const CLERK_TOKEN_EXPIRY_SKEW_MS = 5_000;
18
+// Clerk retries a failed token request itself, but waits 3 s before the first
19
+// retry and longer before each next one. A fresh request usually answers at
20
+// once, so a slow read is replaced instead of waited out.
21
+const CLERK_TOKEN_READ_TIMEOUT_MS = 4_000;
22
+const CLERK_TOKEN_READ_ATTEMPTS = 3;
23
const isManagedRelayRequestFailedError = Schema.is(ManagedRelay.ManagedRelayRequestFailedError);
24
25
export interface ManagedRelaySession {
@@ -66,7 +72,10 @@ const managedRelaySessionControls = new WeakMap<ManagedRelaySession, ManagedRela
72
73
export function createManagedRelaySession(input: ManagedRelaySessionInput): ManagedRelaySession {
74
let cachedToken: { readonly token: string; readonly expiresAtMillis: number } | null = null;
69
- let pendingToken: Promise<string | null> | null = null;
75
+ let pendingToken: {
76
+ readonly operation: Promise<string | null>;
77
+ readonly startedAtMillis: number;
78
+ } | null = null;
79
let readClerkToken = input.readClerkToken;
80
let tokenProviderGeneration = 0;
81
@@ -74,8 +83,10 @@ export function createManagedRelaySession(input: ManagedRelaySessionInput): Mana
83
if (cachedToken && cachedToken.expiresAtMillis > nowMillis + CLERK_TOKEN_EXPIRY_SKEW_MS) {
84
return cachedToken.token;
85
}
77
- if (pendingToken) {
78
- return await pendingToken;
86
+ // A read that outlived its timeout is left running, since it still fills
87
+ // the cache, but later readers start a fresh one instead of joining it.
88
+ if (pendingToken && nowMillis - pendingToken.startedAtMillis < CLERK_TOKEN_READ_TIMEOUT_MS) {
89
+ return await pendingToken.operation;
90
}
91
92
const operationGeneration = tokenProviderGeneration;
@@ -99,11 +110,12 @@ export function createManagedRelaySession(input: ManagedRelaySessionInput): Mana
110
: null;
111
return token;
112
});
102
- pendingToken = operation;
113
+ const pending = { operation, startedAtMillis: nowMillis };
114
+ pendingToken = pending;
115
try {
116
return await operation;
117
} finally {
106
- if (pendingToken === operation) {
118
+ if (pendingToken === pending) {
119
pendingToken = null;
120
}
121
}
@@ -112,14 +124,20 @@ export function createManagedRelaySession(input: ManagedRelaySessionInput): Mana
124
const session: ManagedRelaySession = {
125
accountId: input.accountId,
126
readClerkToken: Effect.fn("clientRuntime.managedRelaySession.readClerkToken")(function* () {
115
- const nowMillis = yield* Clock.currentTimeMillis;
116
- return yield* Effect.tryPromise({
117
- try: () => readCachedClerkToken(nowMillis),
118
- catch: (cause) =>
119
- new ManagedRelaySessionError({
120
- message: "Could not obtain the T3 Connect session token.",
121
- cause,
122
- }),
127
+ for (let attempt = 0; attempt < CLERK_TOKEN_READ_ATTEMPTS; attempt += 1) {
128
+ const nowMillis = yield* Clock.currentTimeMillis;
129
+ const token = yield* Effect.tryPromise({
130
+ try: () => readCachedClerkToken(nowMillis),
131
+ catch: (cause) =>
132
+ new ManagedRelaySessionError({
133
+ message: "Could not obtain the T3 Connect session token.",
134
+ cause,
135
+ }),
136
+ }).pipe(Effect.timeoutOption(CLERK_TOKEN_READ_TIMEOUT_MS));
137
+ if (Option.isSome(token)) return token.value;
138
+ }
139
+ return yield* new ManagedRelaySessionError({
140
+ message: "Timed out obtaining the T3 Connect session token.",
141
});
142
}),
143
};