The best way to control Claude Code, Codex and more from any computer or phone
fix(web): interrupted SSH pairing retries reuse unfinished setup (#19666)
Co-authored-by: Claude Opus 5.5 <noreply@anthropic.com> Co-authored-by: Julius Marminge <julius0216@outlook.com>
Krishna Vijay committed
Oct 19, 2026 at 22:16 UTC
eca0e05512e3d174e9f631ae1e1b156e0561b32f
2 files changed
+156
-8
apps/web/src/connection/platform.test.ts
+122
-1
@@ -3,10 +3,14 @@ import {
3
EnvironmentId,
4
PRIMARY_LOCAL_ENVIRONMENT_ID,
5
type DesktopBridge,
6
+ type DesktopSshEnvironmentBootstrap,
7
type DesktopSshEnvironmentTarget,
8
} from "@t3tools/contracts";
9
import { describe, expect, it } from "@effect/vitest";
10
import * as Effect from "effect/Effect";
11
+import * as Fiber from "effect/Fiber";
12
+import { afterEach, vi } from "vite-plus/test";
13
+import { ClientCapabilities } from "@t3tools/client-runtime/platform";
14
import {
15
ConnectionBlockedError,
16
ConnectionTransientError,
@@ -15,6 +19,7 @@ import {
19
import {
20
canRetainCachedPlatformRegistrationAfterRefreshFailure,
21
canReuseCachedPlatformRegistration,
22
+ layer,
23
isRejectedBootstrapCredentialError,
24
isRejectedSecondaryBootstrap,
25
nextRejectedSecondaryBootstrap,
@@ -34,6 +39,28 @@ const TARGET: DesktopSshEnvironmentTarget = {
39
port: 22,
40
};
41
42
+const SSH_BOOTSTRAP = {
43
+ target: TARGET,
44
+ httpBaseUrl: "http://127.0.0.1:3201/",
45
+ wsBaseUrl: "ws://127.0.0.1:3201/",
46
+ pairingToken: "abandoned-token",
47
+};
48
+
49
+function pendingSetup() {
50
+ let resolve!: (bootstrap: DesktopSshEnvironmentBootstrap) => void;
51
+ let reject!: (cause: unknown) => void;
52
+ const promise = new Promise<DesktopSshEnvironmentBootstrap>((onResolve, onReject) => {
53
+ resolve = onResolve;
54
+ reject = onReject;
55
+ });
56
+ return { promise, resolve, reject };
57
+}
58
+
59
+afterEach(() => {
60
+ vi.unstubAllGlobals();
61
+ vi.restoreAllMocks();
62
+});
63
+
64
function makeBridge(
65
calls: string[],
66
options?: {
@@ -55,6 +82,9 @@ function makeBridge(
82
pairingToken: ensureOptions?.issuePairingToken === true ? "pairing-token" : null,
83
};
84
},
85
+ disconnectSshEnvironment: async () => {
86
+ calls.push("disconnect");
87
+ },
88
fetchSshSessionState: async () => {
89
calls.push("session");
90
return {
@@ -133,17 +163,108 @@ describe("desktop SSH pairing", () => {
163
}),
164
);
165
166
+ it.effect("exchanges one setup credential after repeated interrupted provisions", () =>
167
+ Effect.gen(function* () {
168
+ const bridge = makeBridge([]);
169
+ const setup = pendingSetup();
170
+ const ensure = vi.spyOn(bridge, "ensureSshEnvironment").mockReturnValue(setup.promise);
171
+ const exchange = vi.spyOn(bridge, "bootstrapSshBearerSession");
172
+ for (let attempt = 0; attempt < 2; attempt += 1) {
173
+ const interrupted = yield* Effect.forkChild(
174
+ provisionDesktopSshEnvironment(bridge, TARGET),
175
+ { startImmediately: true },
176
+ );
177
+ yield* Fiber.interrupt(interrupted);
178
+ }
179
+
180
+ const retry = yield* Effect.forkChild(provisionDesktopSshEnvironment(bridge, TARGET), {
181
+ startImmediately: true,
182
+ });
183
+ setup.resolve(SSH_BOOTSTRAP);
184
+ const provisioned = yield* Fiber.join(retry);
185
+
186
+ expect(provisioned.bearerToken).toBe("bearer-token");
187
+ expect(ensure).toHaveBeenCalledExactlyOnceWith(TARGET, { issuePairingToken: true });
188
+ expect(exchange).toHaveBeenCalledExactlyOnceWith(
189
+ SSH_BOOTSTRAP.httpBaseUrl,
190
+ "abandoned-token",
191
+ );
192
+ }),
193
+ );
194
+
195
+ it.effect("starts fresh after an abandoned setup settles in success or failure", () =>
196
+ Effect.gen(function* () {
197
+ for (const outcome of ["success", "failure"]) {
198
+ const bridge = makeBridge([]);
199
+ const setup = pendingSetup();
200
+ const ensure = vi.spyOn(bridge, "ensureSshEnvironment").mockReturnValueOnce(setup.promise);
201
+ const exchange = vi.spyOn(bridge, "bootstrapSshBearerSession");
202
+ const interrupted = yield* Effect.forkChild(
203
+ provisionDesktopSshEnvironment(bridge, TARGET),
204
+ { startImmediately: true },
205
+ );
206
+ yield* Fiber.interrupt(interrupted);
207
+ if (outcome === "success") setup.resolve(SSH_BOOTSTRAP);
208
+ else setup.reject(new Error("remote launch failed"));
209
+ yield* Effect.promise(() =>
210
+ setup.promise.then(
211
+ () => undefined,
212
+ () => undefined,
213
+ ),
214
+ );
215
+
216
+ const provisioned = yield* provisionDesktopSshEnvironment(bridge, TARGET);
217
+
218
+ expect(provisioned.bearerToken).toBe("bearer-token");
219
+ expect(ensure).toHaveBeenCalledTimes(2);
220
+ expect(exchange).toHaveBeenCalledExactlyOnceWith(
221
+ SSH_BOOTSTRAP.httpBaseUrl,
222
+ "pairing-token",
223
+ );
224
+ }
225
+ }),
226
+ );
227
+
228
+ it.effect("disconnect invalidates unfinished setup even before provision is interrupted", () =>
229
+ Effect.gen(function* () {
230
+ const calls: string[] = [];
231
+ const bridge = makeBridge(calls);
232
+ const setup = pendingSetup();
233
+ const ensure = vi.spyOn(bridge, "ensureSshEnvironment").mockReturnValueOnce(setup.promise);
234
+ const exchange = vi.spyOn(bridge, "bootstrapSshBearerSession");
235
+ vi.stubGlobal("window", { desktopBridge: bridge });
236
+ const ssh = yield* ClientCapabilities.SshEnvironmentGateway.pipe(Effect.provide(layer));
237
+ const interrupted = yield* Effect.forkChild(ssh.provision(TARGET), {
238
+ startImmediately: true,
239
+ });
240
+ yield* ssh.disconnect(TARGET);
241
+ yield* Fiber.interrupt(interrupted);
242
+
243
+ const retry = yield* Effect.forkChild(ssh.provision(TARGET), { startImmediately: true });
244
+ setup.resolve(SSH_BOOTSTRAP);
245
+ const provisioned = yield* Fiber.join(retry);
246
+
247
+ expect(provisioned.bearerToken).toBe("bearer-token");
248
+ expect(ensure).toHaveBeenCalledTimes(2);
249
+ expect(calls).toEqual(["disconnect", "ensure", "descriptor", "token"]);
250
+ expect(exchange).toHaveBeenCalledExactlyOnceWith(SSH_BOOTSTRAP.httpBaseUrl, "pairing-token");
251
+ }),
252
+ );
253
+
254
it.effect("reconnects with the saved token while it holds every standard scope", () =>
255
Effect.gen(function* () {
256
const calls: string[] = [];
257
140
- const prepared = yield* prepareDesktopSshEnvironment(makeBridge(calls), {
258
+ const bridge = makeBridge(calls);
259
+ const ensure = vi.spyOn(bridge, "ensureSshEnvironment");
260
+ const prepared = yield* prepareDesktopSshEnvironment(bridge, {
261
target: TARGET,
262
expectedEnvironmentId: EnvironmentId.make("environment-ssh"),
263
bearerToken: "saved-token",
264
});
265
266
expect(prepared.bearerToken).toBe("saved-token");
267
+ expect(ensure).toHaveBeenCalledExactlyOnceWith(TARGET, { issuePairingToken: false });
268
expect(calls).toEqual(["ensure", "descriptor", "session"]);
269
}),
270
);
apps/web/src/connection/platform.ts
+34
-7
@@ -16,6 +16,7 @@ import {
16
type PlatformConnectionRegistration,
17
PrimaryConnectionRegistration,
18
PrimaryConnectionTarget,
19
+ sshTargetKey,
20
Wakeups,
21
} from "@t3tools/client-runtime/connection";
22
import { bootstrapRemoteBearerSession } from "@t3tools/client-runtime/authorization";
@@ -26,6 +27,7 @@ import {
27
AuthStandardClientScopes,
28
type DesktopBridge,
29
type DesktopEnvironmentBootstrap,
30
+ type DesktopSshEnvironmentBootstrap,
31
type DesktopSshEnvironmentTarget,
32
type EnvironmentId,
33
PRIMARY_LOCAL_ENVIRONMENT_ID,
@@ -178,6 +180,36 @@ function sshPreparationError(cause: unknown) {
180
});
181
}
182
183
+// IPC keeps running after its waiter is interrupted. A retry can adopt only
184
+// that interrupted waiter's unfinished setup.
185
+const pendingSshSetups = new Map<
186
+ string,
187
+ { readonly promise: Promise<DesktopSshEnvironmentBootstrap>; signal: AbortSignal }
188
+>();
189
+
190
+const ensureDesktopSshEnvironment = (bridge: DesktopBridge, target: DesktopSshEnvironmentTarget) =>
191
+ Effect.tryPromise({
192
+ try: (signal) => {
193
+ const key = sshTargetKey(target);
194
+ const pending = pendingSshSetups.get(key);
195
+ if (pending?.signal.aborted) {
196
+ pending.signal = signal;
197
+ return pending.promise;
198
+ }
199
+ const setup = {
200
+ promise: bridge.ensureSshEnvironment(target, { issuePairingToken: true }),
201
+ signal,
202
+ };
203
+ pendingSshSetups.set(key, setup);
204
+ const forget = () => {
205
+ if (pendingSshSetups.get(key) === setup) pendingSshSetups.delete(key);
206
+ };
207
+ setup.promise.then(forget, forget);
208
+ return setup.promise;
209
+ },
210
+ catch: sshPreparationError,
211
+ });
212
+
213
export const provisionDesktopSshEnvironment = Effect.fn(
214
"web.connectionPlatform.ssh.provisionDesktop",
215
)(function* (
@@ -185,13 +217,7 @@ export const provisionDesktopSshEnvironment = Effect.fn(
217
target: DesktopSshEnvironmentTarget,
218
expectedEnvironmentId?: EnvironmentId,
219
) {
188
- const bootstrap = yield* Effect.tryPromise({
189
- try: () =>
190
- bridge.ensureSshEnvironment(target, {
191
- issuePairingToken: true,
192
- }),
193
- catch: sshPreparationError,
194
- });
220
+ const bootstrap = yield* ensureDesktopSshEnvironment(bridge, target);
221
const pairingToken = bootstrap.pairingToken;
222
if (pairingToken === null) {
223
return yield* new ConnectionBlockedError({
@@ -352,6 +378,7 @@ const layerCapabilities = Layer.effectContext(
378
if (bridge === undefined) {
379
return;
380
}
381
+ pendingSshSetups.delete(sshTargetKey(target));
382
yield* Effect.tryPromise({
383
try: () => bridge.disconnectSshEnvironment(target),
384
catch: (cause) =>