@devries-cameron20 / t3code Mirror · read-only / commits / eca0e05512
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, 22:00 UTC

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) =>