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, 22:15 UTC
fix(client-runtime): slow SSH runtime downloads report their own error, not a setup timeout (#29264)
Julius Marminge committed
Nov 11, 2026 at 15:27 UTC
6c7d23dcfca7cde03c7f5843e432d98122f40a55
4 files changed
+226
-7
packages/client-runtime/src/connection/driver.test.ts
new
+74
@@ -0,0 +1,74 @@
1
+import { EnvironmentId } from "@t3tools/contracts";
2
+import { describe, expect, it } from "@effect/vitest";
3
+import * as Effect from "effect/Effect";
4
+import * as Layer from "effect/Layer";
5
+import * as Option from "effect/Option";
6
+import * as Ref from "effect/Ref";
7
+import * as FetchHttpClient from "effect/http/FetchHttpClient";
8
+
9
+import * as RemoteEnvironmentAuthorization from "../authorization/service.ts";
10
+import * as RpcSession from "../rpc/session.ts";
11
+import type { ConnectionCatalogEntry } from "./catalog.ts";
12
+import * as ConnectionDriver from "./driver.ts";
13
+import { ConnectionTransientError, SshConnectionTarget, type PreparedConnection } from "./model.ts";
14
+import * as ConnectionResolver from "./resolver.ts";
15
+
16
+const sshTarget = (connectionId: string) =>
17
+ new SshConnectionTarget({
18
+ environmentId: EnvironmentId.make("environment-1"),
19
+ label: "Test environment",
20
+ connectionId,
21
+ });
22
+
23
+const ENTRY: ConnectionCatalogEntry = {
24
+ target: sshTarget("ssh-first"),
25
+ profile: Option.none(),
26
+ enabled: true,
27
+ alternateRoutes: [{ target: sshTarget("ssh-second"), profile: Option.none() }],
28
+};
29
+
30
+describe("ConnectionDriver", () => {
31
+ it.effect("reports preparing before each route it prepares", () =>
32
+ Effect.gen(function* () {
33
+ const stages = yield* Ref.make<ReadonlyArray<string>>([]);
34
+ const driver = yield* ConnectionDriver.make.pipe(
35
+ Effect.provide(
36
+ Layer.mergeAll(
37
+ Layer.mock(ConnectionResolver.ConnectionResolver)({
38
+ prepare: (entry) =>
39
+ Effect.succeed({
40
+ environmentId: entry.target.environmentId,
41
+ label: entry.target.label,
42
+ httpBaseUrl: "http://127.0.0.1:1",
43
+ socketUrl: "ws://127.0.0.1:1/ws",
44
+ httpAuthorization: null,
45
+ target: entry.target,
46
+ } satisfies PreparedConnection),
47
+ }),
48
+ Layer.mock(RpcSession.RpcSessionFactory)({
49
+ connect: () =>
50
+ Effect.fail(
51
+ new ConnectionTransientError({ reason: "transport", detail: "Socket closed." }),
52
+ ),
53
+ }),
54
+ Layer.mock(RemoteEnvironmentAuthorization.RemoteEnvironmentAuthorization)({}),
55
+ // SSH routes have no HTTP check, so the driver never sends a request.
56
+ FetchHttpClient.layer,
57
+ ),
58
+ ),
59
+ );
60
+
61
+ yield* driver
62
+ .connect(ENTRY, (progress) => Ref.update(stages, (all) => [...all, progress.stage]))
63
+ .pipe(Effect.scoped, Effect.flip);
64
+
65
+ expect(yield* Ref.get(stages)).toEqual([
66
+ "preparing",
67
+ "preparing",
68
+ "opening",
69
+ "preparing",
70
+ "opening",
71
+ ]);
72
+ }),
73
+ );
74
+});
packages/client-runtime/src/connection/driver.ts
+1
@@ -199,6 +199,7 @@ export const make = Effect.gen(function* () {
199
entry,
200
(route) => checkRoute(entry, route),
201
Effect.fnUntraced(function* (route) {
202
+ yield* reportProgress({ stage: "preparing" });
203
const prepared = yield* resolver.prepare(routeEntry(entry, route));
204
yield* reportProgress({ stage: "opening", prepared });
205
const session = yield* sessions.connect(prepared);
packages/client-runtime/src/connection/supervisor.test.ts
+133
@@ -7,6 +7,7 @@ import {
7
import { describe, expect, it } from "@effect/vitest";
8
import * as Deferred from "effect/Deferred";
9
import * as Effect from "effect/Effect";
10
+import * as Fiber from "effect/Fiber";
11
import * as Layer from "effect/Layer";
12
import * as Option from "effect/Option";
13
import * as Random from "effect/Random";
@@ -32,6 +33,7 @@ import {
33
ConnectionTransientError,
34
PrimaryConnectionTarget,
35
RelayConnectionTarget,
36
+ SshConnectionTarget,
37
type ConnectionAttemptError,
38
type ConnectionTarget,
39
type NetworkStatus,
@@ -103,6 +105,16 @@ const LAN_THEN_RELAY_ENTRY: ConnectionCatalogEntry = {
105
enabled: true,
106
};
107
108
+const SSH_ENTRY: ConnectionCatalogEntry = {
109
+ target: new SshConnectionTarget({
110
+ environmentId: TARGET.environmentId,
111
+ label: TARGET.label,
112
+ connectionId: "ssh-connection",
113
+ }),
114
+ profile: Option.none(),
115
+ enabled: true,
116
+};
117
+
118
const LAN_ENTRY: ConnectionCatalogEntry = {
119
target: LAN_ROUTE.target,
120
profile: LAN_ROUTE.profile,
@@ -194,6 +206,7 @@ const makeHarness = Effect.fn("TestConnectionHarness.make")(function* (options?:
206
target: ConnectionTarget,
207
reportProgress: (progress: ConnectionDriver.ConnectionDriverProgress) => Effect.Effect<void>,
208
) {
209
+ yield* reportProgress({ stage: "preparing" });
210
const prepared = yield* prepare(target);
211
yield* reportProgress({ stage: "opening", prepared });
212
@@ -556,6 +569,126 @@ describe("EnvironmentSupervisor", () => {
569
}).pipe(Effect.provide(TestClock.layer())),
570
);
571
572
+ it.effect("reports a slow SSH preparation failure instead of the setup timeout", () =>
573
+ Effect.gen(function* () {
574
+ const preparationFailure = new ConnectionTransientError({
575
+ reason: "remote-unavailable",
576
+ detail:
577
+ "Could not prepare the SSH environment: curl: (28) Operation timed out after 240003 milliseconds",
578
+ });
579
+ const harness = yield* makeHarness({
580
+ prepare: () =>
581
+ Effect.sleep("4 minutes").pipe(Effect.andThen(Effect.fail(preparationFailure))),
582
+ });
583
+ const supervisor = yield* EnvironmentSupervisor.make(SSH_ENTRY, {
584
+ initiallyDesired: true,
585
+ }).pipe(Effect.provide(harness.dependencies));
586
+
587
+ yield* awaitState(
588
+ supervisor.state,
589
+ (state) => state.phase === "connecting" && state.stage === "preparing",
590
+ );
591
+ const firstFailure = yield* awaitState(
592
+ supervisor.state,
593
+ (state) => state.phase === "backoff",
594
+ ).pipe(Effect.forkChild({ startImmediately: true }));
595
+ yield* TestClock.adjust("4 minutes");
596
+
597
+ expect(yield* Fiber.join(firstFailure)).toMatchObject({
598
+ attempt: 1,
599
+ lastFailure: {
600
+ _tag: "ConnectionTransientError",
601
+ reason: "remote-unavailable",
602
+ message: preparationFailure.message,
603
+ },
604
+ });
605
+ }).pipe(Effect.provide(TestClock.layer())),
606
+ );
607
+
608
+ it.effect("times out an SSH route that stops answering after a slow preparation", () =>
609
+ Effect.gen(function* () {
610
+ const harness = yield* makeHarness({
611
+ prepare: () => Effect.sleep("4 minutes").pipe(Effect.as(PREPARED_CONNECTION)),
612
+ ready: () => Effect.never,
613
+ });
614
+ const supervisor = yield* EnvironmentSupervisor.make(SSH_ENTRY, {
615
+ initiallyDesired: true,
616
+ }).pipe(Effect.provide(harness.dependencies));
617
+
618
+ yield* awaitState(
619
+ supervisor.state,
620
+ (state) => state.phase === "connecting" && state.stage === "preparing",
621
+ );
622
+ yield* TestClock.adjust("4 minutes");
623
+ yield* awaitState(
624
+ supervisor.state,
625
+ (state) => state.phase === "connecting" && state.stage === "synchronizing",
626
+ );
627
+ const firstFailure = yield* awaitState(
628
+ supervisor.state,
629
+ (state) => state.phase === "backoff",
630
+ ).pipe(Effect.forkChild({ startImmediately: true }));
631
+ yield* TestClock.adjust("90 seconds");
632
+
633
+ expect(yield* Fiber.join(firstFailure)).toMatchObject({
634
+ attempt: 1,
635
+ lastFailure: {
636
+ _tag: "ConnectionTransientError",
637
+ reason: "timeout",
638
+ message: "Test environment did not respond during connection setup.",
639
+ },
640
+ });
641
+ }).pipe(Effect.provide(TestClock.layer())),
642
+ );
643
+
644
+ it.effect("does not time a second SSH route's slow preparation", () =>
645
+ Effect.gen(function* () {
646
+ const secondSshTarget = new SshConnectionTarget({
647
+ environmentId: TARGET.environmentId,
648
+ label: TARGET.label,
649
+ connectionId: "ssh-connection-2",
650
+ });
651
+ const firstRouteFailure = transient("The first SSH route dropped while synchronizing.");
652
+ const harness = yield* makeHarness({
653
+ prepare: (attempt, target) =>
654
+ attempt === 1
655
+ ? Effect.succeed(preparedFor(target))
656
+ : Effect.sleep("4 minutes").pipe(
657
+ Effect.andThen(
658
+ Effect.fail(
659
+ new ConnectionTransientError({
660
+ reason: "remote-unavailable",
661
+ detail: "Could not prepare the SSH environment.",
662
+ }),
663
+ ),
664
+ ),
665
+ ),
666
+ ready: () => Effect.fail(firstRouteFailure),
667
+ });
668
+ const supervisor = yield* EnvironmentSupervisor.make(
669
+ { ...SSH_ENTRY, alternateRoutes: [{ target: secondSshTarget, profile: Option.none() }] },
670
+ { initiallyDesired: true },
671
+ ).pipe(Effect.provide(harness.dependencies));
672
+
673
+ yield* awaitState(
674
+ supervisor.state,
675
+ (state) => state.phase === "connecting" && state.stage === "preparing",
676
+ );
677
+ const firstFailure = yield* awaitState(
678
+ supervisor.state,
679
+ (state) => state.phase === "backoff",
680
+ ).pipe(Effect.forkChild({ startImmediately: true }));
681
+ yield* TestClock.adjust("4 minutes");
682
+
683
+ // The driver reports the first transient failure across its routes.
684
+ expect(yield* Fiber.join(firstFailure)).toMatchObject({
685
+ attempt: 1,
686
+ lastFailure: { reason: "transport", message: firstRouteFailure.message },
687
+ });
688
+ expect(yield* Ref.get(harness.prepareCount)).toBe(2);
689
+ }).pipe(Effect.provide(TestClock.layer())),
690
+ );
691
+
692
it.effect("treats an involuntary session close as transient and reconnects", () =>
693
Effect.gen(function* () {
694
const harness = yield* makeHarness();
packages/client-runtime/src/connection/supervisor.ts
+18
-7
@@ -909,18 +909,29 @@ export const make = Effect.fn("EnvironmentSupervisor.make")(function* (
909
// each route that reaches synchronizing adds its own snapshot budget, so
910
// a route that fails late does not eat the next route's time.
911
Effect.gen(function* () {
912
- const routeCount = connectionRoutes(yield* Ref.get(currentEntry)).length;
913
- const startedAt = yield* Clock.monotonicTimeNanos;
914
- const setup = Duration.toNanosUnsafe(Duration.times(establishmentTimeout, routeCount));
912
+ const routes = connectionRoutes(yield* Ref.get(currentEntry));
913
+ const setup = Duration.toNanosUnsafe(Duration.times(establishmentTimeout, routes.length));
914
+ // The desktop bounds SSH preparation, which may download a server
915
+ // release, so for SSH-only entries the clock stops while preparing.
916
+ const pausesWhilePreparing = routes.every((route) => connectionRouteKind(route) === "ssh");
917
+ const preparing = (expected: boolean) =>
918
+ SubscriptionRef.changes(state).pipe(
919
+ Stream.filter((current) => (current.stage === "preparing") === expected),
920
+ Stream.runHead,
921
+ );
922
+ let spent = 0n;
923
while (true) {
924
+ if (pausesWhilePreparing) yield* preparing(false);
925
const synchronized = BigInt(yield* Ref.get(synchronizedRoutes));
917
- const deadline =
918
- startedAt + setup + synchronized * Duration.toNanosUnsafe(synchronizationTimeout);
919
- const remaining = deadline - (yield* Clock.monotonicTimeNanos);
926
+ const remaining =
927
+ setup + synchronized * Duration.toNanosUnsafe(synchronizationTimeout) - spent;
928
if (remaining <= 0n) {
929
return { _tag: "TimedOut" } as const satisfies EstablishmentEvent;
930
}
923
- yield* Effect.sleep(Duration.nanos(remaining));
931
+ const resumedAt = yield* Clock.monotonicTimeNanos;
932
+ const sleep = Effect.sleep(Duration.nanos(remaining));
933
+ yield* pausesWhilePreparing ? Effect.raceFirst(sleep, preparing(true)) : sleep;
934
+ spent += (yield* Clock.monotonicTimeNanos) - resumedAt;
935
}
936
}),
937
]);