@devries-cameron20 / t3code Mirror · read-only / commits / 7c22095fcc
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 21, 19:45 UTC

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 };