@devries-cameron20 / t3code Mirror · read-only / commits / f6433dba45
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, 23:30 UTC

fix(desktop): an SSH password prompt that ended leaves the dialog instead of stacking (#34192)

Co-authored-by: Claude Opus 5.5 <noreply@anthropic.com> Co-authored-by: Julius Marminge <julius0216@outlook.com>

M.Umais Adeed committed Nov 11, 2026 at 15:20 UTC f6433dba45ae0022f17513e2c0cfc76a632eb835
7 files changed +144 -20
apps/desktop/src/ipc/channels.ts
+1
@@ -70,6 +70,7 @@ export const BOOTSTRAP_SSH_BEARER_SESSION_CHANNEL = "desktop:bootstrap-ssh-beare
70 export const FETCH_SSH_SESSION_STATE_CHANNEL = "desktop:fetch-ssh-session-state";
71 export const SSH_PASSWORD_PROMPT_CHANNEL = "desktop:ssh-password-prompt";
72 export const RESOLVE_SSH_PASSWORD_PROMPT_CHANNEL = "desktop:resolve-ssh-password-prompt";
73 +export const SSH_PASSWORD_PROMPT_SETTLED_CHANNEL = "desktop:ssh-password-prompt-settled";
74 export const GET_SERVER_EXPOSURE_STATE_CHANNEL = "desktop:get-server-exposure-state";
75 export const SET_SERVER_EXPOSURE_MODE_CHANNEL = "desktop:set-server-exposure-mode";
76 export const SET_TAILSCALE_SERVE_ENABLED_CHANNEL = "desktop:set-tailscale-serve-enabled";
apps/desktop/src/preload.ts
+11
@@ -195,6 +195,17 @@ contextBridge.exposeInMainWorld("desktopBridge", {
195 ipcRenderer.removeListener(IpcChannels.SSH_PASSWORD_PROMPT_CHANNEL, wrappedListener);
196 };
197 },
198 + onSshPasswordPromptSettled: (listener) => {
199 + const wrappedListener = (_event: Electron.IpcRendererEvent, requestId: unknown) => {
200 + if (typeof requestId !== "string") return;
201 + listener(requestId);
202 + };
203 +
204 + ipcRenderer.on(IpcChannels.SSH_PASSWORD_PROMPT_SETTLED_CHANNEL, wrappedListener);
205 + return () => {
206 + ipcRenderer.removeListener(IpcChannels.SSH_PASSWORD_PROMPT_SETTLED_CHANNEL, wrappedListener);
207 + };
208 + },
209 resolveSshPasswordPrompt: (requestId, password) =>
210 ipcRenderer.invoke(IpcChannels.RESOLVE_SSH_PASSWORD_PROMPT_CHANNEL, { requestId, password }),
211 getServerExposureState: () => ipcRenderer.invoke(IpcChannels.GET_SERVER_EXPOSURE_STATE_CHANNEL),
apps/desktop/src/ssh/DesktopSshPasswordPrompts.test.ts
+50 -1
@@ -8,7 +8,10 @@ import * as TestClock from "effect/testing/TestClock";
8 import type * as Electron from "electron";
9
10 import * as ElectronWindow from "../electron/ElectronWindow.ts";
11 -import { SSH_PASSWORD_PROMPT_CHANNEL } from "../ipc/channels.ts";
11 +import {
12 + SSH_PASSWORD_PROMPT_CHANNEL,
13 + SSH_PASSWORD_PROMPT_SETTLED_CHANNEL,
14 +} from "../ipc/channels.ts";
15 import * as DesktopSshPasswordPrompts from "./DesktopSshPasswordPrompts.ts";
16
17 interface SentMessage {
@@ -144,6 +147,52 @@ describe("DesktopSshPasswordPrompts", () => {
147 }).pipe(Effect.provide(layer(testWindow.window)), Effect.scoped);
148 });
149
150 + it.effect.each(["answered", "cancelled", "timed out", "interrupted"] as const)(
151 + "tells the window a prompt ended when it is %s",
152 + (outcome) => {
153 + const testWindow = makeTestWindow();
154 +
155 + return Effect.gen(function* () {
156 + const prompts = yield* DesktopSshPasswordPrompts.DesktopSshPasswordPrompts;
157 + const fiber = yield* prompts
158 + .request({
159 + destination: "devbox",
160 + username: "julius",
161 + prompt: "Enter the SSH password.",
162 + attempt: 1,
163 + })
164 + .pipe(Effect.exit, Effect.forkScoped);
165 +
166 + yield* Effect.yieldNow;
167 + yield* Effect.yieldNow;
168 + const request = testWindow.sentMessages[0]?.args[0] as { readonly requestId: string };
169 + assert.ok(request);
170 + switch (outcome) {
171 + case "answered":
172 + yield* prompts.resolve({ requestId: request.requestId, password: "secret" });
173 + break;
174 + case "cancelled":
175 + yield* prompts.resolve({ requestId: request.requestId, password: null });
176 + break;
177 + case "timed out":
178 + yield* TestClock.adjust("1 second");
179 + break;
180 + case "interrupted":
181 + yield* Fiber.interrupt(fiber);
182 + break;
183 + }
184 + yield* Fiber.await(fiber);
185 +
186 + assert.deepEqual(
187 + testWindow.sentMessages
188 + .filter((message) => message.channel === SSH_PASSWORD_PROMPT_SETTLED_CHANNEL)
189 + .map((message) => message.args),
190 + [[request.requestId]],
191 + );
192 + }).pipe(Effect.provide(layer(testWindow.window)), Effect.scoped);
193 + },
194 + );
195 +
196 it.effect("keeps a submitted password when a later presentation step fails", () => {
197 const testWindow = makeTestWindow({
198 isMinimizedError: new Error("failed to read minimized state"),
apps/desktop/src/ssh/DesktopSshPasswordPrompts.ts
+17 -2
@@ -13,7 +13,10 @@ import * as Ref from "effect/Ref";
13 import * as Schema from "effect/Schema";
14
15 import * as ElectronWindow from "../electron/ElectronWindow.ts";
16 -import { SSH_PASSWORD_PROMPT_CHANNEL } from "../ipc/channels.ts";
16 +import {
17 + SSH_PASSWORD_PROMPT_CHANNEL,
18 + SSH_PASSWORD_PROMPT_SETTLED_CHANNEL,
19 +} from "../ipc/channels.ts";
20
21 const DEFAULT_SSH_PASSWORD_PROMPT_TIMEOUT_MS = 3 * 60 * 1000;
22
@@ -38,6 +41,7 @@ const DesktopSshPromptPresentationOperation = Schema.Literals([
41 "check-window-after-restore",
42 "focus-window",
43 "remove-window-close-listener",
44 + "send-prompt-settled",
45 ]);
46 type DesktopSshPromptPresentationOperation = typeof DesktopSshPromptPresentationOperation.Type;
47
@@ -371,11 +375,22 @@ export const make = Effect.fn("desktop.sshPasswordPrompts.make")(function* (
375 cause,
376 }),
377 });
378 + // However the request ends, the window drops its prompt, so no ended prompt stays on screen.
379 + const notifySettled = runPresentationOperation("send-prompt-settled", () => {
380 + if (!window.value.isDestroyed()) {
381 + window.value.webContents.send(SSH_PASSWORD_PROMPT_SETTLED_CHANNEL, requestId);
382 + }
383 + }).pipe(Effect.ignore);
384 const cleanup = runPresentationOperation("remove-window-close-listener", () => {
385 if (!window.value.isDestroyed()) {
386 window.value.removeListener("closed", cancelOnWindowClosed);
387 }
378 - }).pipe(Effect.orDie, Effect.ensuring(removePending(pendingRef, requestId)), Effect.asVoid);
388 + }).pipe(
389 + Effect.orDie,
390 + Effect.ensuring(removePending(pendingRef, requestId)),
391 + Effect.ensuring(notifySettled),
392 + Effect.asVoid,
393 + );
394 const waitForPassword = Deferred.await(deferred).pipe(
395 Effect.timeoutOption(Duration.millis(passwordPromptTimeoutMs)),
396 Effect.flatMap(
apps/web/src/components/desktop/SshPasswordPromptDialog.browser.test.tsx
+50 -11
@@ -4,28 +4,67 @@ import { expect, it } from "vite-plus/test";
4 import { render, stubGlobal } from "../../../test/render";
5 import { SshPasswordPromptDialog, startSshPasswordPromptQueue } from "./SshPasswordPromptDialog";
6
7 -it("shows a prompt that arrived before the dialog mounted", async () => {
7 +function stubPromptBridge() {
8 const listeners: Array<(request: DesktopSshPasswordPromptRequest) => void> = [];
9 - using _bridge = stubGlobal("desktopBridge", {
9 + const settledListeners: Array<(requestId: string) => void> = [];
10 + const bridge = stubGlobal("desktopBridge", {
11 onSshPasswordPrompt: (listener: (request: DesktopSshPasswordPromptRequest) => void) => {
12 listeners.push(listener);
13 return () => listeners.splice(listeners.indexOf(listener), 1);
14 },
15 + onSshPasswordPromptSettled: (listener: (requestId: string) => void) => {
16 + settledListeners.push(listener);
17 + return () => settledListeners.splice(settledListeners.indexOf(listener), 1);
18 + },
19 resolveSshPasswordPrompt: async () => undefined,
20 });
21 + return {
22 + prompt: (requestId: string, destination: string) => {
23 + for (const listener of listeners) {
24 + listener({
25 + requestId,
26 + destination,
27 + username: "julius",
28 + prompt: `julius@${destination}'s password:`,
29 + expiresAt: "2999-01-01T00:00:00.000Z",
30 + });
31 + }
32 + },
33 + settle: (requestId: string) => {
34 + for (const listener of settledListeners) listener(requestId);
35 + },
36 + [Symbol.dispose]: () => bridge[Symbol.dispose](),
37 + };
38 +}
39 +
40 +it("drops a prompt the desktop ended, whether it is on screen or still waiting", async () => {
41 + using bridge = stubPromptBridge();
42 + const stopQueue = startSshPasswordPromptQueue();
43 + using _queue = { [Symbol.dispose]: stopQueue };
44 + await using screen = await render(<SshPasswordPromptDialog />);
45 +
46 + bridge.prompt("ssh-1", "first-host");
47 + bridge.prompt("ssh-1", "first-host");
48 + bridge.prompt("ssh-2", "second-host");
49 + bridge.prompt("ssh-3", "third-host");
50 + await expect.element(screen.getByText("julius@first-host")).toBeVisible();
51 +
52 + // ssh-2 ended while it waited behind ssh-1, and ssh-1 ended on screen.
53 + bridge.settle("ssh-2");
54 + bridge.settle("ssh-1");
55 + await expect.element(screen.getByText("julius@third-host")).toBeVisible();
56 +
57 + bridge.settle("ssh-3");
58 + await expect.element(screen.getByText("SSH verification required")).not.toBeInTheDocument();
59 +});
60 +
61 +it("shows a prompt that arrived before the dialog mounted", async () => {
62 + using bridge = stubPromptBridge();
63 const stopQueue = startSshPasswordPromptQueue();
64 using _queue = { [Symbol.dispose]: stopQueue };
65
66 // The desktop asks while the app is still on a page without the dialog (pairing, sign-in).
20 - for (const listener of listeners) {
21 - listener({
22 - requestId: "ssh-1",
23 - destination: "devbox",
24 - username: "julius",
25 - prompt: "julius@devbox's password:",
26 - expiresAt: "2999-01-01T00:00:00.000Z",
27 - });
28 - }
67 + bridge.prompt("ssh-1", "devbox");
68
69 await using screen = await render(<SshPasswordPromptDialog />);
70 await expect.element(screen.getByText("SSH verification required")).toBeVisible();
apps/web/src/components/desktop/SshPasswordPromptDialog.tsx
+13 -6
@@ -47,11 +47,17 @@ function setPromptQueue(next: readonly DesktopSshPasswordPromptRequest[]) {
47 * that arrives while no dialog is mounted still waits for one.
48 */
49 export function startSshPasswordPromptQueue(): () => void {
50 - return (
51 - window.desktopBridge?.onSshPasswordPrompt((request) => {
52 - setPromptQueue([...promptQueue, request]);
53 - }) ?? (() => undefined)
54 - );
50 + const bridge = window.desktopBridge;
51 + if (!bridge) return () => undefined;
52 + const stopPrompts = bridge.onSshPasswordPrompt((request) => {
53 + if (promptQueue.some((queued) => queued.requestId === request.requestId)) return;
54 + setPromptQueue([...promptQueue, request]);
55 + });
56 + const stopSettled = bridge.onSshPasswordPromptSettled(removeSshPasswordPrompt);
57 + return () => {
58 + stopPrompts();
59 + stopSettled();
60 + };
61 }
62
63 function subscribePromptQueue(listener: () => void): () => void {
@@ -64,7 +70,8 @@ function subscribePromptQueue(listener: () => void): () => void {
70 const readPromptQueue = () => promptQueue;
71
72 function removeSshPasswordPrompt(requestId: string) {
67 - if (promptQueue[0]?.requestId === requestId) setPromptQueue(promptQueue.slice(1));
73 + if (!promptQueue.some((request) => request.requestId === requestId)) return;
74 + setPromptQueue(promptQueue.filter((request) => request.requestId !== requestId));
75 }
76
77 export function SshPasswordPromptDialog() {
packages/contracts/src/ipc.ts
+2
@@ -1110,6 +1110,8 @@ export interface DesktopBridge {
1110 ) => Promise<AuthAccessTokenResult>;
1111 fetchSshSessionState: (httpBaseUrl: string, bearerToken: string) => Promise<AuthSessionState>;
1112 onSshPasswordPrompt: (listener: (request: DesktopSshPasswordPromptRequest) => void) => () => void;
1113 + /** Fires with a prompt's request id once it is answered, cancelled, expired or abandoned. */
1114 + onSshPasswordPromptSettled: (listener: (requestId: string) => void) => () => void;
1115 resolveSshPasswordPrompt: (requestId: string, password: string | null) => Promise<void>;
1116 getServerExposureState: () => Promise<DesktopServerExposureState>;
1117 setServerExposureMode: (mode: DesktopServerExposureMode) => Promise<DesktopServerExposureState>;