From 6e558a4772cb3ed081bd208e96ef04dd8620c767 Mon Sep 17 00:00:00 2001 From: Samuel K Date: Sun, 4 Oct 2026 16:29:27 +0000 Subject: [PATCH 1/3] fix(desktop): clarify remembered unlock outcomes --- .../main/__tests__/ipc-secret-session.test.ts | 197 +++++++++++++++++- desktop/src/main/ipc.ts | 61 +++++- .../layout/SecretUnlockDialog.svelte | 34 ++- .../layout/SecretUnlockDialog.test.ts | 82 ++++++++ .../docs/developing-in-workspaces/secrets.mdx | 5 + 5 files changed, 351 insertions(+), 28 deletions(-) diff --git a/desktop/src/main/__tests__/ipc-secret-session.test.ts b/desktop/src/main/__tests__/ipc-secret-session.test.ts index db63cc1dd3..5b6f14f583 100644 --- a/desktop/src/main/__tests__/ipc-secret-session.test.ts +++ b/desktop/src/main/__tests__/ipc-secret-session.test.ts @@ -460,7 +460,7 @@ describe("secret unlock IPC lifecycle", () => { args.remember = false args.requestId = "changed-request" approve({ response: 1, checkboxChecked: false }) - await expect(submission).resolves.toEqual({ ok: true }) + await expect(submission).resolves.toEqual({ ok: true, remembered: true }) expect(cli.runRaw).toHaveBeenCalledExactlyOnceWith( ["secret", "protection", "remember"], { @@ -472,6 +472,167 @@ describe("secret unlock IPC lifecycle", () => { expect(cli.setSessionPassphrase).not.toHaveBeenCalled() }) + it.each(["dialog", "cli"] as const)( + "rejects duplicate credential submissions during the %s await while allowing cancellation", + async (stage) => { + const { cli, event, unlock, requestId } = setup() + const pending = unlock() + let finishDialog!: (value: { + response: number + checkboxChecked: boolean + }) => void + let finishCli!: (value: string) => void + if (stage === "dialog") + vi.mocked(dialog.showMessageBox).mockImplementation( + () => + new Promise((resolve) => { + finishDialog = resolve + }), + ) + else + cli.runRaw.mockImplementation( + () => + new Promise((resolve) => { + finishCli = resolve + }), + ) + + const args = { + requestId: requestId(), + passphrase: "private", + remember: true, + } + const submission = handlers.get("secret_unlock_submit")?.(event, args) + if (stage === "cli") + await vi.waitFor(() => expect(cli.runRaw).toHaveBeenCalledOnce()) + + for (const remember of [true, false]) + await expect( + handlers.get("secret_unlock_submit")?.(event, { + ...args, + remember, + passphrase: "duplicate-private", + }), + ).resolves.toEqual({ + ok: false, + message: "An unlock submission is already in progress.", + }) + + // A credential-free submission remains an available cancellation path. + await handlers.get("secret_unlock_submit")?.(event, { + requestId: args.requestId, + }) + await expect(pending).resolves.toBeUndefined() + if (stage === "dialog") + finishDialog({ response: 1, checkboxChecked: false }) + else finishCli("") + await expect(submission).resolves.toEqual( + stage === "cli" + ? { + ok: false, + remembered: true, + message: + "The passphrase was saved in the OS keychain, but unlocking was canceled. Use Forget to remove the remembered credential.", + } + : { + ok: false, + message: "Unlock request is no longer active.", + }, + ) + }, + ) + + it("reports a saved credential when navigation cancels after the remember CLI succeeds", async () => { + const { cli, event, unlock, webContents, requestId } = setup() + const pending = unlock() + cli.runRaw.mockImplementation(async () => { + webContents.emit("did-start-navigation", {}, "app://reload", false, true) + return "" + }) + await expect( + handlers.get("secret_unlock_submit")?.(event, { + requestId: requestId(), + passphrase: "private", + remember: true, + }), + ).resolves.toEqual({ + ok: false, + remembered: true, + message: + "The passphrase was saved in the OS keychain, but unlocking was canceled. Use Forget to remove the remembered credential.", + }) + await expect(pending).resolves.toBeUndefined() + }) + + it("does not report a saved credential after a remember CLI failure and releases the submission claim", async () => { + const { cli, event, unlock, requestId } = setup() + const pending = unlock() + cli.runRaw + .mockRejectedValueOnce(new Error("keychain unavailable")) + .mockResolvedValueOnce("") + const firstId = requestId() + await expect( + handlers.get("secret_unlock_submit")?.(event, { + requestId: firstId, + passphrase: "private", + remember: true, + }), + ).resolves.toEqual({ + ok: false, + message: "The passphrase could not be verified and remembered.", + }) + expect(cli.setSessionPassphrase).not.toHaveBeenCalled() + await expect( + handlers.get("secret_unlock_submit")?.(event, { + requestId: firstId, + passphrase: "private", + remember: true, + }), + ).resolves.toEqual({ ok: true, remembered: true }) + await expect(pending).resolves.toBe("private") + }) + + it("allows a new request to proceed while an older remember CLI call is pending", async () => { + const { cli, event, unlock, webContents, requestId } = setup() + const first = unlock() + const oldId = requestId() + let finishFirstCli!: (value: string) => void + cli.runRaw + .mockImplementationOnce( + () => + new Promise((resolve) => { + finishFirstCli = resolve + }), + ) + .mockResolvedValueOnce("") + const firstSubmission = handlers.get("secret_unlock_submit")?.(event, { + requestId: oldId, + passphrase: "older-private", + remember: true, + }) + await vi.waitFor(() => expect(cli.runRaw).toHaveBeenCalledOnce()) + webContents.emit("did-start-navigation", {}, "app://reload", false, true) + await expect(first).resolves.toBeUndefined() + + const second = unlock() + const newId = requestId() + expect(newId).not.toBe(oldId) + await expect( + handlers.get("secret_unlock_submit")?.(event, { + requestId: newId, + passphrase: "newer-private", + remember: true, + }), + ).resolves.toEqual({ ok: true, remembered: true }) + await expect(second).resolves.toBe("newer-private") + + finishFirstCli("") + await expect(firstSubmission).resolves.toMatchObject({ + ok: false, + remembered: true, + }) + }) + it.each(["dialog", "cli"] as const)( "cannot settle a replacement request after navigation during %s", async (stage) => { @@ -521,10 +682,19 @@ describe("secret unlock IPC lifecycle", () => { if (stage === "dialog") finishDialog({ response: 1, checkboxChecked: false }) else finishCli("") - await expect(submission).resolves.toEqual({ - ok: false, - message: "Unlock request is no longer active.", - }) + await expect(submission).resolves.toEqual( + stage === "cli" + ? { + ok: false, + remembered: true, + message: + "The passphrase was saved in the OS keychain, but unlocking was canceled. Use Forget to remove the remembered credential.", + } + : { + ok: false, + message: "Unlock request is no longer active.", + }, + ) expect(newSettled).toBe(false) expect(cli.runRaw).toHaveBeenCalledTimes(stage === "dialog" ? 0 : 1) expect(cli.setSessionPassphrase).not.toHaveBeenCalled() @@ -558,10 +728,19 @@ describe("secret unlock IPC lifecycle", () => { passphrase: "private", remember: true, }), - ).toEqual({ - ok: false, - message: "Secret operations require the main application window.", - }) + ).toEqual( + stage === "cli" + ? { + ok: false, + remembered: true, + message: + "The passphrase was saved in the OS keychain, but unlocking was canceled. Use Forget to remove the remembered credential.", + } + : { + ok: false, + message: "Secret operations require the main application window.", + }, + ) expect(cli.runRaw).toHaveBeenCalledTimes(stage === "dialog" ? 0 : 1) expect(cli.setSessionPassphrase).not.toHaveBeenCalled() webContents.emit("render-process-gone") diff --git a/desktop/src/main/ipc.ts b/desktop/src/main/ipc.ts index a31b92cda8..7717da9105 100644 --- a/desktop/src/main/ipc.ts +++ b/desktop/src/main/ipc.ts @@ -51,6 +51,10 @@ interface SecretIpcFailure { message: string } +type SecretUnlockResult = (SecretIpcFailure | { ok: true }) & { + remembered?: true +} + type SecretUnlockInput = | SecretIpcFailure | { ok: true; requestId?: string; passphrase?: string; remember: boolean } @@ -405,6 +409,14 @@ export function registerIpcHandlers(deps: IpcDependencies): { message: "Unlock request is no longer active.", } + const rememberedUnlockCanceled: SecretUnlockResult = { + ok: false, + remembered: true, + message: + "The passphrase was saved in the OS keychain, but unlocking was canceled. Use Forget to remove the remembered credential.", + } + const credentialSubmissions = new Set() + function pendingSecretUnlockFailure( event: Electron.IpcMainInvokeEvent, requestId: string | undefined, @@ -420,13 +432,14 @@ export function registerIpcHandlers(deps: IpcDependencies): { win: BrowserWindow, requestId: string | undefined, passphrase: string, - ): Promise { + ): Promise { try { const confirmation = await dialog.showMessageBox(win, { type: "warning", title: "Secret protection", message: "Remember the secrets passphrase in your OS keychain?", - detail: "This changes the shared secret store across all contexts.", + detail: + "This changes the shared secret store across all contexts. Approved saving may finish after unlock cancellation; Forget removes the saved credential.", buttons: ["Cancel", "Continue"], defaultId: 0, cancelId: 0, @@ -440,7 +453,9 @@ export function registerIpcHandlers(deps: IpcDependencies): { env: { DEVSY_SECRETS_PASSPHRASE: passphrase }, unlockRetried: true, }) - return pendingSecretUnlockFailure(event, requestId) + if (pendingSecretUnlockFailure(event, requestId)) + return rememberedUnlockCanceled + return { ok: true, remembered: true } } catch { return { ok: false, @@ -461,6 +476,27 @@ export function registerIpcHandlers(deps: IpcDependencies): { return { ok: true } } + async function applySecretUnlockCredential( + event: Electron.IpcMainInvokeEvent, + win: BrowserWindow, + requestId: string, + passphrase: string, + remember: boolean, + ): Promise { + if (!remember) return completeSecretUnlock(event, requestId, passphrase) + const remembered = await rememberUnlockCredential( + event, + win, + requestId, + passphrase, + ) + if (!remembered.ok) return remembered + // Approval authorizes persistence, but stale completion must not settle a newer unlock. + const completed = completeSecretUnlock(event, requestId, passphrase) + if (!completed.ok) return rememberedUnlockCanceled + return { ok: true, remembered: true } + } + ipcMain.handle("secret_unlock_submit", async (event, args: unknown) => { const win = getMainWindow() if (!win || !isTrustedSecretIpcSender(event, win, secretDocumentURL)) @@ -469,17 +505,26 @@ export function registerIpcHandlers(deps: IpcDependencies): { if (!input.ok) return input const { requestId, passphrase, remember } = input if (!secretSession.isPending(requestId)) return staleSecretUnlockRequest - if (passphrase !== undefined && remember) { - const failure = await rememberUnlockCredential( + // Cancellation remains available while this request's approved remember is running. + if (passphrase === undefined) + return completeSecretUnlock(event, requestId, undefined) + if (credentialSubmissions.has(requestId)) + return { + ok: false, + message: "An unlock submission is already in progress.", + } + credentialSubmissions.add(requestId) + try { + return await applySecretUnlockCredential( event, win, requestId, passphrase, + remember, ) - if (failure) return failure + } finally { + credentialSubmissions.delete(requestId) } - // Revalidate after the optional asynchronous remember helper before settling. - return completeSecretUnlock(event, requestId, passphrase) }) ipcMain.handle("secret_protection_status", async (event) => { if (!isTrustedSecretIpcSender(event, getMainWindow(), secretDocumentURL)) diff --git a/desktop/src/renderer/src/lib/components/layout/SecretUnlockDialog.svelte b/desktop/src/renderer/src/lib/components/layout/SecretUnlockDialog.svelte index ea8767f2d3..24febbc524 100644 --- a/desktop/src/renderer/src/lib/components/layout/SecretUnlockDialog.svelte +++ b/desktop/src/renderer/src/lib/components/layout/SecretUnlockDialog.svelte @@ -4,6 +4,7 @@ import * as Dialog from "$lib/components/ui/dialog/index.js" import { Button } from "$lib/components/ui/button/index.js" import { Input } from "$lib/components/ui/input/index.js" import { refreshSecrets } from "$lib/stores/secrets.js" +import { toasts } from "$lib/stores/toasts.js" import { invoke, listen } from "$lib/ipc/bridge.js" let open = $state(false) let passphrase = $state("") @@ -40,17 +41,28 @@ async function submit() { const submittedRemember = remember busy = true try { - const result = await invoke<{ ok: boolean; message?: string }>( - "secret_unlock_submit", - { - requestId: submittedRequestId, - passphrase: submittedPassphrase, - remember: submittedRemember, - }, - ) + const result = await invoke<{ + ok: boolean + remembered?: boolean + message?: string + }>("secret_unlock_submit", { + requestId: submittedRequestId, + passphrase: submittedPassphrase, + remember: submittedRemember, + }) + if ( + result.remembered === true && + (!result.ok || requestId !== submittedRequestId) + ) { + toasts.info( + result.message ?? + "The passphrase was saved in your OS keychain. Use Forget in Settings to remove it.", + { sticky: true }, + ) + } if (requestId !== submittedRequestId) return passphrase = "" - if (result.ok) { + if (result.ok || result.remembered === true) { requestId = "" open = false remember = false @@ -88,10 +100,10 @@ function cancel() {
{ event.preventDefault(); void submit() }} class="space-y-4"> -

Remembering allows Devsy CLI and Desktop to recover the credential through your OS credential store.

+

Once approved, remembering may finish even if you cancel unlocking. Use Forget in Settings to remove the saved credential.

{#if error}{/if} - +
diff --git a/desktop/src/renderer/src/lib/components/layout/SecretUnlockDialog.test.ts b/desktop/src/renderer/src/lib/components/layout/SecretUnlockDialog.test.ts index df15956bee..d5b8fe395e 100644 --- a/desktop/src/renderer/src/lib/components/layout/SecretUnlockDialog.test.ts +++ b/desktop/src/renderer/src/lib/components/layout/SecretUnlockDialog.test.ts @@ -1,12 +1,14 @@ import { fireEvent, render, screen, waitFor } from "@testing-library/svelte" import { beforeEach, describe, expect, it, vi } from "vitest" import { invoke, listen } from "$lib/ipc/bridge.js" +import { toasts } from "$lib/stores/toasts.js" import SecretUnlockDialog from "./SecretUnlockDialog.svelte" vi.mock("$lib/stores/secrets.js", () => ({ refreshSecrets: vi.fn(async () => undefined), })) vi.mock("$lib/ipc/bridge.js", () => ({ invoke: vi.fn(), listen: vi.fn() })) +vi.mock("$lib/stores/toasts.js", () => ({ toasts: { info: vi.fn() } })) describe("SecretUnlockDialog", () => { let request: (requestId?: unknown) => void @@ -111,4 +113,84 @@ describe("SecretUnlockDialog", () => { expect((input as HTMLInputElement).disabled).toBe(true) unmount() }) + + it("allows cancellation while saving and reports a completed remember after the dialog closes", async () => { + let finish!: (result: { + ok: boolean + remembered: boolean + message: string + }) => void + vi.mocked(invoke).mockImplementationOnce( + () => + new Promise((resolve) => { + finish = resolve + }), + ) + const { unmount } = render(SecretUnlockDialog) + await waitFor(() => expect(listen).toHaveBeenCalled()) + request("remember-request") + const input = await screen.findByLabelText("Secrets passphrase") + await fireEvent.input(input, { target: { value: "private credential" } }) + await fireEvent.click(screen.getByLabelText("Remember in OS keychain")) + await fireEvent.click(screen.getByText("Unlock and retry")) + await fireEvent.click(screen.getByText("Cancel")) + expect(invoke).toHaveBeenLastCalledWith("secret_unlock_submit", { + requestId: "remember-request", + }) + const message = + "The passphrase was saved in the OS keychain, but unlocking was canceled. Use Forget to remove the remembered credential." + finish({ ok: false, remembered: true, message }) + await waitFor(() => + expect(toasts.info).toHaveBeenCalledWith(message, { sticky: true }), + ) + expect(screen.queryByLabelText("Secrets passphrase")).toBeNull() + expect(JSON.stringify(vi.mocked(toasts.info).mock.calls)).not.toContain( + "private credential", + ) + unmount() + }) + + it("reports an older remembered outcome without changing the replacement dialog", async () => { + let finish!: (result: { ok: boolean; remembered: boolean }) => void + vi.mocked(invoke).mockImplementationOnce( + () => + new Promise((resolve) => { + finish = resolve + }), + ) + const { unmount } = render(SecretUnlockDialog) + await waitFor(() => expect(listen).toHaveBeenCalled()) + request("old-remember") + const input = await screen.findByLabelText("Secrets passphrase") + await fireEvent.input(input, { target: { value: "old credential" } }) + await fireEvent.click(screen.getByText("Unlock and retry")) + request("new-unlock") + await fireEvent.input(input, { target: { value: "new credential" } }) + finish({ ok: false, remembered: true }) + await waitFor(() => expect(toasts.info).toHaveBeenCalledOnce()) + expect( + (screen.getByLabelText("Secrets passphrase") as HTMLInputElement).value, + ).toBe("new credential") + expect( + (screen.getByLabelText("Secrets passphrase") as HTMLInputElement) + .disabled, + ).toBe(false) + unmount() + }) + + it("does not report remembered success for a failed save", async () => { + vi.mocked(invoke).mockResolvedValueOnce({ + ok: false, + message: "Could not save the credential.", + }) + const { unmount } = render(SecretUnlockDialog) + await waitFor(() => expect(listen).toHaveBeenCalled()) + request("failed-remember") + const input = await screen.findByLabelText("Secrets passphrase") + await fireEvent.input(input, { target: { value: "private credential" } }) + await fireEvent.click(screen.getByText("Unlock and retry")) + await screen.findByText("Could not save the credential.") + expect(toasts.info).not.toHaveBeenCalled() + unmount() + }) }) diff --git a/sites/docs-devsy-sh/content/docs/developing-in-workspaces/secrets.mdx b/sites/docs-devsy-sh/content/docs/developing-in-workspaces/secrets.mdx index a7312d18e2..387c980b47 100644 --- a/sites/docs-devsy-sh/content/docs/developing-in-workspaces/secrets.mdx +++ b/sites/docs-devsy-sh/content/docs/developing-in-workspaces/secrets.mdx @@ -423,6 +423,11 @@ approved protection change already running may finish, but it will not restore the cleared session credential. Remembered OS-keychain credentials remain until you choose **Forget**. +While an unlock submission is running, another credential submission for that +request is rejected. You can still cancel unlocking. If an approved Remember +action then succeeds, Desktop reports that the credential was saved even though +unlocking was canceled. Use **Forget** in Settings to remove it. + Passphrase protection applies to all values in the file backend. It is not a secret storage backend or a per-secret setting. To supply the passphrase, Devsy checks sources in this order: explicit input from the invoking UI or process, From 8d4c93731b8e5d6ce6b480b92fddb9d2455b05d3 Mon Sep 17 00:00:00 2001 From: Samuel K Date: Sun, 4 Oct 2026 17:12:58 +0000 Subject: [PATCH 2/3] fix(desktop): retain remembered notices across reloads --- .../main/__tests__/ipc-secret-session.test.ts | 197 ++++++++++++++++++ desktop/src/main/ipc.ts | 53 ++++- .../layout/SecretUnlockDialog.svelte | 53 ++++- .../layout/SecretUnlockDialog.test.ts | 143 +++++++++++-- .../docs/developing-in-workspaces/secrets.mdx | 4 +- 5 files changed, 414 insertions(+), 36 deletions(-) diff --git a/desktop/src/main/__tests__/ipc-secret-session.test.ts b/desktop/src/main/__tests__/ipc-secret-session.test.ts index 5b6f14f583..5664967e0e 100644 --- a/desktop/src/main/__tests__/ipc-secret-session.test.ts +++ b/desktop/src/main/__tests__/ipc-secret-session.test.ts @@ -633,6 +633,203 @@ describe("secret unlock IPC lifecycle", () => { }) }) + it("keeps a late saved-credential notice through navigation until a trusted replacement renderer acknowledges it", async () => { + const { cli, event, unlock, webContents, requestId } = setup() + const pending = unlock() + const id = requestId() + cli.runRaw.mockImplementation(async () => { + webContents.emit("did-start-navigation", {}, "app://reload", false, true) + return "" + }) + const result = await handlers.get("secret_unlock_submit")?.(event, { + requestId: id, + passphrase: "secret-value", + remember: true, + }) + expect(result).toMatchObject({ ok: false, remembered: true }) + await expect(pending).resolves.toBeUndefined() + + const replacementFrame = { + url: pathToFileURL(join(__dirname, "../../renderer/index.html")).href, + isDestroyed: () => false, + } + webContents.mainFrame = replacementFrame + const replacementEvent = { + sender: webContents, + senderFrame: replacementFrame, + } + const notices = handlers.get("secret_unlock_notices") + const noticeResult = { + ok: true, + notices: [{ requestId: id, message: expect.any(String) }], + } + expect(await notices?.(replacementEvent)).toEqual(noticeResult) + expect(await notices?.(replacementEvent)).toEqual(noticeResult) + expect(webContents.send).toHaveBeenCalledWith("secret_unlock_notice") + expect(JSON.stringify(await notices?.(replacementEvent))).not.toContain( + "secret-value", + ) + expect( + await handlers.get("secret_unlock_notice_ack")?.(replacementEvent, { + requestId: id, + }), + ).toEqual({ ok: true }) + expect(await notices?.(replacementEvent)).toEqual({ + ok: true, + notices: [], + }) + }) + + it("rejects untrusted notice reads and acknowledgements without consuming the notice", async () => { + const { cli, event, unlock, webContents, requestId } = setup() + const pending = unlock() + const id = requestId() + cli.runRaw.mockImplementation(async () => { + webContents.emit("did-start-navigation", {}, "app://reload", false, true) + return "" + }) + await handlers.get("secret_unlock_submit")?.(event, { + requestId: id, + passphrase: "private", + remember: true, + }) + await expect(pending).resolves.toBeUndefined() + webContents.mainFrame.url = "https://untrusted.example/" + const untrusted = { + sender: webContents, + senderFrame: webContents.mainFrame, + } + const denied = { + ok: false, + message: "Secret operations require the main application window.", + } + expect(await handlers.get("secret_unlock_notices")?.(untrusted)).toEqual( + denied, + ) + expect( + await handlers.get("secret_unlock_notice_ack")?.(untrusted, { + requestId: id, + }), + ).toEqual(denied) + const trustedFrame = { + url: pathToFileURL(join(__dirname, "../../renderer/index.html")).href, + isDestroyed: () => false, + } + webContents.mainFrame = trustedFrame + const trusted = { sender: webContents, senderFrame: trustedFrame } + expect( + await handlers.get("secret_unlock_notices")?.(trusted), + ).toMatchObject({ + ok: true, + notices: [{ requestId: id }], + }) + }) + + it("rejects invalid notice acknowledgements and treats unknown IDs as successful", async () => { + const { event } = setup() + const ack = handlers.get("secret_unlock_notice_ack") + expect(await ack?.(event, {})).toEqual({ + ok: false, + message: "A valid unlock request ID is required.", + }) + expect(await ack?.(event, { requestId: "unknown" })).toEqual({ + ok: true, + }) + }) + + it("does not queue notices for declined or failed saves or for a normal unlock", async () => { + const { cli, event, unlock, requestId } = setup() + const notices = handlers.get("secret_unlock_notices") + const declinedPending = unlock() + vi.mocked(dialog.showMessageBox).mockResolvedValue({ + response: 0, + checkboxChecked: false, + }) + await handlers.get("secret_unlock_submit")?.(event, { + requestId: requestId(), + passphrase: "private", + remember: true, + }) + await handlers.get("secret_unlock_submit")?.(event, { + requestId: requestId(), + }) + await expect(declinedPending).resolves.toBeUndefined() + expect(await notices?.(event)).toEqual({ ok: true, notices: [] }) + + vi.mocked(dialog.showMessageBox).mockResolvedValue({ + response: 1, + checkboxChecked: false, + }) + const failedPending = unlock() + cli.runRaw.mockRejectedValueOnce(new Error("keychain unavailable")) + await handlers.get("secret_unlock_submit")?.(event, { + requestId: requestId(), + passphrase: "private", + remember: true, + }) + await handlers.get("secret_unlock_submit")?.(event, { + requestId: requestId(), + }) + await expect(failedPending).resolves.toBeUndefined() + expect(await notices?.(event)).toEqual({ ok: true, notices: [] }) + + const normalPending = unlock() + await handlers.get("secret_unlock_submit")?.(event, { + requestId: requestId(), + passphrase: "private", + remember: true, + }) + await expect(normalPending).resolves.toBe("private") + expect(await notices?.(event)).toEqual({ ok: true, notices: [] }) + }) + + it.each(["throw", "destroy"] as const)( + "keeps the notice queued if the wakeup send %s", + async (failure) => { + const { cli, event, unlock, webContents, requestId } = setup() + const pending = unlock() + const id = requestId() + cli.runRaw.mockImplementation(async () => { + webContents.emit( + "did-start-navigation", + {}, + "app://reload", + false, + true, + ) + if (failure === "destroy") webContents.isDestroyed = () => true + return "" + }) + if (failure === "throw") { + // Fail the next send (the canceled unlock wakeup) after the initial prompt. + webContents.send.mockImplementation((channel: string) => { + if (channel === "secret_unlock_notice") throw new Error("closed") + }) + } + const result = await handlers.get("secret_unlock_submit")?.(event, { + requestId: id, + passphrase: "private", + remember: true, + }) + await expect(pending).resolves.toBeUndefined() + expect(result).toMatchObject({ ok: false, remembered: true }) + + webContents.isDestroyed = () => false + const frame = { + url: pathToFileURL(join(__dirname, "../../renderer/index.html")).href, + isDestroyed: () => false, + } + webContents.mainFrame = frame + const replacement = { sender: webContents, senderFrame: frame } + expect( + await handlers.get("secret_unlock_notices")?.(replacement), + ).toMatchObject({ + ok: true, + notices: [{ requestId: id }], + }) + }, + ) + it.each(["dialog", "cli"] as const)( "cannot settle a replacement request after navigation during %s", async (stage) => { diff --git a/desktop/src/main/ipc.ts b/desktop/src/main/ipc.ts index 7717da9105..c127546743 100644 --- a/desktop/src/main/ipc.ts +++ b/desktop/src/main/ipc.ts @@ -409,13 +409,55 @@ export function registerIpcHandlers(deps: IpcDependencies): { message: "Unlock request is no longer active.", } - const rememberedUnlockCanceled: SecretUnlockResult = { + const rememberedUnlockCanceled = { ok: false, remembered: true, message: "The passphrase was saved in the OS keychain, but unlocking was canceled. Use Forget to remove the remembered credential.", - } + } satisfies SecretUnlockResult const credentialSubmissions = new Set() + const secretUnlockNotices = new Map< + string, + { requestId: string; message: string } + >() + + function retainRememberedUnlockNotice(requestId: string): SecretUnlockResult { + if (!secretUnlockNotices.has(requestId)) { + secretUnlockNotices.set(requestId, { + requestId, + message: rememberedUnlockCanceled.message, + }) + try { + const win = getMainWindow() + if (win && !win.isDestroyed() && !win.webContents.isDestroyed()) + win.webContents.send("secret_unlock_notice") + } catch { + // The replacement renderer can fetch retained notices after mounting. + } + } + return rememberedUnlockCanceled + } + + ipcMain.handle("secret_unlock_notices", (event) => { + if (!isTrustedSecretIpcSender(event, getMainWindow(), secretDocumentURL)) + return secretRequestDenied + return { ok: true, notices: [...secretUnlockNotices.values()] } + }) + ipcMain.handle("secret_unlock_notice_ack", (event, args: unknown) => { + if (!isTrustedSecretIpcSender(event, getMainWindow(), secretDocumentURL)) + return secretRequestDenied + const requestId = + args && + typeof args === "object" && + !Array.isArray(args) && + "requestId" in args + ? args.requestId + : undefined + if (typeof requestId !== "string" || !requestId.trim()) + return { ok: false, message: "A valid unlock request ID is required." } + secretUnlockNotices.delete(requestId) + return { ok: true } + }) function pendingSecretUnlockFailure( event: Electron.IpcMainInvokeEvent, @@ -490,10 +532,13 @@ export function registerIpcHandlers(deps: IpcDependencies): { requestId, passphrase, ) - if (!remembered.ok) return remembered + if (!remembered.ok) + return remembered.remembered + ? retainRememberedUnlockNotice(requestId) + : remembered // Approval authorizes persistence, but stale completion must not settle a newer unlock. const completed = completeSecretUnlock(event, requestId, passphrase) - if (!completed.ok) return rememberedUnlockCanceled + if (!completed.ok) return retainRememberedUnlockNotice(requestId) return { ok: true, remembered: true } } diff --git a/desktop/src/renderer/src/lib/components/layout/SecretUnlockDialog.svelte b/desktop/src/renderer/src/lib/components/layout/SecretUnlockDialog.svelte index 24febbc524..6691336327 100644 --- a/desktop/src/renderer/src/lib/components/layout/SecretUnlockDialog.svelte +++ b/desktop/src/renderer/src/lib/components/layout/SecretUnlockDialog.svelte @@ -15,6 +15,48 @@ let requestId = $state("") onMount(() => { let destroyed = false let unlisten: (() => void) | undefined + let unlistenNotices: (() => void) | undefined + let readingNotices = false + let readRequested = false + const shownNotices = new Set() + async function reportRememberedNotices() { + readRequested = true + if (readingNotices) return + readingNotices = true + try { + while (readRequested && !destroyed) { + readRequested = false + const result = await invoke<{ + ok: boolean + notices?: { requestId: string; message: string }[] + }>("secret_unlock_notices") + if (destroyed || !result.ok) return + for (const notice of result.notices ?? []) { + if (destroyed) return + if (!shownNotices.has(notice.requestId)) { + toasts.info(notice.message, { sticky: true }) + shownNotices.add(notice.requestId) + } + await invoke("secret_unlock_notice_ack", { + requestId: notice.requestId, + }) + } + } + } catch { + // Main retains unacknowledged outcomes for the next event or page mount. + } finally { + readingNotices = false + } + } + void listen("secret_unlock_notice", () => { + void reportRememberedNotices() + }).then((off) => { + if (destroyed) off() + else { + unlistenNotices = off + void reportRememberedNotices() + } + }) void listen<{ requestId?: unknown }>("secret_unlock_required", (event) => { const nextRequestId = event.payload?.requestId if (typeof nextRequestId !== "string" || !nextRequestId.trim()) return @@ -32,6 +74,7 @@ onMount(() => { return () => { destroyed = true unlisten?.() + unlistenNotices?.() } }) async function submit() { @@ -50,16 +93,6 @@ async function submit() { passphrase: submittedPassphrase, remember: submittedRemember, }) - if ( - result.remembered === true && - (!result.ok || requestId !== submittedRequestId) - ) { - toasts.info( - result.message ?? - "The passphrase was saved in your OS keychain. Use Forget in Settings to remove it.", - { sticky: true }, - ) - } if (requestId !== submittedRequestId) return passphrase = "" if (result.ok || result.remembered === true) { diff --git a/desktop/src/renderer/src/lib/components/layout/SecretUnlockDialog.test.ts b/desktop/src/renderer/src/lib/components/layout/SecretUnlockDialog.test.ts index d5b8fe395e..3f502e66a2 100644 --- a/desktop/src/renderer/src/lib/components/layout/SecretUnlockDialog.test.ts +++ b/desktop/src/renderer/src/lib/components/layout/SecretUnlockDialog.test.ts @@ -12,13 +12,37 @@ vi.mock("$lib/stores/toasts.js", () => ({ toasts: { info: vi.fn() } })) describe("SecretUnlockDialog", () => { let request: (requestId?: unknown) => void + let notify: () => void + let notices: { requestId: string; message: string }[] + let submit: () => Promise<{ + ok: boolean + remembered?: boolean + message?: string + }> beforeEach(() => { - vi.clearAllMocks() - vi.mocked(listen).mockImplementation(async (_name, callback) => { - request = (requestId) => callback({ payload: { requestId } }) + vi.resetAllMocks() + notices = [] + submit = async () => ({ ok: true }) + vi.mocked(listen).mockImplementation(async (name, callback) => { + if (name === "secret_unlock_required") + request = (requestId) => callback({ payload: { requestId } }) + else if (name === "secret_unlock_notice") + notify = () => callback({ payload: undefined }) return vi.fn<() => void>() }) - vi.mocked(invoke).mockResolvedValue({ ok: true }) + vi.mocked(invoke).mockImplementation(async (command, args) => { + if (command === "secret_unlock_notices") + return { ok: true, notices: [...notices] } + if (command === "secret_unlock_notice_ack") { + notices = notices.filter( + (notice) => notice.requestId !== args?.requestId, + ) + return { ok: true } + } + if (command === "secret_unlock_submit" && args?.passphrase !== undefined) + return submit() + return { ok: true } + }) }) it("opens on a main-process unlock request and submits only with explicit remember selection", async () => { const { unmount } = render(SecretUnlockDialog) @@ -66,9 +90,7 @@ describe("SecretUnlockDialog", () => { it("keeps a newer request intact when an older submit resolves later", async () => { let resolveOld!: (value: { ok: boolean }) => void - vi.mocked(invoke).mockImplementationOnce( - () => new Promise((resolve) => (resolveOld = resolve)), - ) + submit = () => new Promise((resolve) => (resolveOld = resolve)) const { unmount } = render(SecretUnlockDialog) await waitFor(() => expect(listen).toHaveBeenCalled()) @@ -101,7 +123,7 @@ describe("SecretUnlockDialog", () => { }) it("does not reset typing or busy state when the same request is re-notified", async () => { - vi.mocked(invoke).mockImplementationOnce(() => new Promise(() => {})) + submit = () => new Promise(() => {}) const { unmount } = render(SecretUnlockDialog) await waitFor(() => expect(listen).toHaveBeenCalled()) request("request-same") @@ -120,12 +142,10 @@ describe("SecretUnlockDialog", () => { remembered: boolean message: string }) => void - vi.mocked(invoke).mockImplementationOnce( - () => - new Promise((resolve) => { - finish = resolve - }), - ) + submit = () => + new Promise((resolve) => { + finish = resolve + }) const { unmount } = render(SecretUnlockDialog) await waitFor(() => expect(listen).toHaveBeenCalled()) request("remember-request") @@ -139,6 +159,8 @@ describe("SecretUnlockDialog", () => { }) const message = "The passphrase was saved in the OS keychain, but unlocking was canceled. Use Forget to remove the remembered credential." + notices = [{ requestId: "remember-request", message }] + notify() finish({ ok: false, remembered: true, message }) await waitFor(() => expect(toasts.info).toHaveBeenCalledWith(message, { sticky: true }), @@ -152,12 +174,10 @@ describe("SecretUnlockDialog", () => { it("reports an older remembered outcome without changing the replacement dialog", async () => { let finish!: (result: { ok: boolean; remembered: boolean }) => void - vi.mocked(invoke).mockImplementationOnce( - () => - new Promise((resolve) => { - finish = resolve - }), - ) + submit = () => + new Promise((resolve) => { + finish = resolve + }) const { unmount } = render(SecretUnlockDialog) await waitFor(() => expect(listen).toHaveBeenCalled()) request("old-remember") @@ -166,6 +186,13 @@ describe("SecretUnlockDialog", () => { await fireEvent.click(screen.getByText("Unlock and retry")) request("new-unlock") await fireEvent.input(input, { target: { value: "new credential" } }) + notices = [ + { + requestId: "old-remember", + message: "Saved credential; use Forget to remove it.", + }, + ] + notify() finish({ ok: false, remembered: true }) await waitFor(() => expect(toasts.info).toHaveBeenCalledOnce()) expect( @@ -179,7 +206,7 @@ describe("SecretUnlockDialog", () => { }) it("does not report remembered success for a failed save", async () => { - vi.mocked(invoke).mockResolvedValueOnce({ + submit = async () => ({ ok: false, message: "Could not save the credential.", }) @@ -193,4 +220,78 @@ describe("SecretUnlockDialog", () => { expect(toasts.info).not.toHaveBeenCalled() unmount() }) + + it("replays a late saved notice on the replacement page and acknowledges it after display", async () => { + let finish!: (result: { ok: boolean; remembered: boolean }) => void + submit = () => + new Promise((resolve) => { + finish = resolve + }) + const oldPage = render(SecretUnlockDialog) + await waitFor(() => + expect(invoke).toHaveBeenCalledWith("secret_unlock_notices"), + ) + request("reloaded-request") + const input = await screen.findByLabelText("Secrets passphrase") + await fireEvent.input(input, { target: { value: "private credential" } }) + await fireEvent.click(screen.getByLabelText("Remember in OS keychain")) + await fireEvent.click(screen.getByText("Unlock and retry")) + oldPage.unmount() + notices = [ + { + requestId: "reloaded-request", + message: "Saved in OS keychain; use Forget to remove it.", + }, + ] + finish({ ok: false, remembered: true }) + await Promise.resolve() + expect(toasts.info).not.toHaveBeenCalled() + const newPage = render(SecretUnlockDialog) + await waitFor(() => + expect(toasts.info).toHaveBeenCalledExactlyOnceWith( + "Saved in OS keychain; use Forget to remove it.", + { sticky: true }, + ), + ) + await waitFor(() => + expect(invoke).toHaveBeenCalledWith("secret_unlock_notice_ack", { + requestId: "reloaded-request", + }), + ) + expect(notices).toEqual([]) + notify() + await waitFor(() => + expect(invoke).toHaveBeenCalledWith("secret_unlock_notices"), + ) + expect(toasts.info).toHaveBeenCalledOnce() + newPage.unmount() + }) + + it("does not display or acknowledge a fetched notice after its page is destroyed", async () => { + let finish!: (result: { + ok: boolean + notices: { requestId: string; message: string }[] + }) => void + vi.mocked(invoke).mockImplementationOnce( + () => + new Promise((resolve) => { + finish = resolve + }), + ) + const oldPage = render(SecretUnlockDialog) + await waitFor(() => + expect(invoke).toHaveBeenCalledWith("secret_unlock_notices"), + ) + oldPage.unmount() + finish({ + ok: true, + notices: [{ requestId: "old-page", message: "Saved credential" }], + }) + await Promise.resolve() + expect(toasts.info).not.toHaveBeenCalled() + expect(invoke).not.toHaveBeenCalledWith( + "secret_unlock_notice_ack", + expect.anything(), + ) + }) }) diff --git a/sites/docs-devsy-sh/content/docs/developing-in-workspaces/secrets.mdx b/sites/docs-devsy-sh/content/docs/developing-in-workspaces/secrets.mdx index 387c980b47..83bc1eab58 100644 --- a/sites/docs-devsy-sh/content/docs/developing-in-workspaces/secrets.mdx +++ b/sites/docs-devsy-sh/content/docs/developing-in-workspaces/secrets.mdx @@ -426,7 +426,9 @@ until you choose **Forget**. While an unlock submission is running, another credential submission for that request is rejected. You can still cancel unlocking. If an approved Remember action then succeeds, Desktop reports that the credential was saved even though -unlocking was canceled. Use **Forget** in Settings to remove it. +unlocking was canceled. The main process retains this notice across a page +reload until Desktop displays and acknowledges it. Use **Forget** in Settings +to remove the credential. Passphrase protection applies to all values in the file backend. It is not a secret storage backend or a per-secret setting. To supply the passphrase, Devsy From d8170f834fa32c40bf72ccc1d4de0553a3a8ea47 Mon Sep 17 00:00:00 2001 From: Samuel K Date: Sun, 4 Oct 2026 18:02:08 +0000 Subject: [PATCH 3/3] fix(desktop): report late saves without a wakeup --- .../layout/SecretUnlockDialog.svelte | 10 +++-- .../layout/SecretUnlockDialog.test.ts | 45 +++++++++++++++++++ 2 files changed, 52 insertions(+), 3 deletions(-) diff --git a/desktop/src/renderer/src/lib/components/layout/SecretUnlockDialog.svelte b/desktop/src/renderer/src/lib/components/layout/SecretUnlockDialog.svelte index 6691336327..b8483ef0d0 100644 --- a/desktop/src/renderer/src/lib/components/layout/SecretUnlockDialog.svelte +++ b/desktop/src/renderer/src/lib/components/layout/SecretUnlockDialog.svelte @@ -12,6 +12,7 @@ let remember = $state(false) let busy = $state(false) let error = $state("") let requestId = $state("") +let readRememberedNotices: () => void = () => {} onMount(() => { let destroyed = false let unlisten: (() => void) | undefined @@ -48,13 +49,14 @@ onMount(() => { readingNotices = false } } - void listen("secret_unlock_notice", () => { + readRememberedNotices = () => { void reportRememberedNotices() - }).then((off) => { + } + void listen("secret_unlock_notice", readRememberedNotices).then((off) => { if (destroyed) off() else { unlistenNotices = off - void reportRememberedNotices() + readRememberedNotices() } }) void listen<{ requestId?: unknown }>("secret_unlock_required", (event) => { @@ -73,6 +75,7 @@ onMount(() => { }) return () => { destroyed = true + readRememberedNotices = () => {} unlisten?.() unlistenNotices?.() } @@ -93,6 +96,7 @@ async function submit() { passphrase: submittedPassphrase, remember: submittedRemember, }) + if (!result.ok && result.remembered === true) readRememberedNotices() if (requestId !== submittedRequestId) return passphrase = "" if (result.ok || result.remembered === true) { diff --git a/desktop/src/renderer/src/lib/components/layout/SecretUnlockDialog.test.ts b/desktop/src/renderer/src/lib/components/layout/SecretUnlockDialog.test.ts index 3f502e66a2..b29f79d6c6 100644 --- a/desktop/src/renderer/src/lib/components/layout/SecretUnlockDialog.test.ts +++ b/desktop/src/renderer/src/lib/components/layout/SecretUnlockDialog.test.ts @@ -294,4 +294,49 @@ describe("SecretUnlockDialog", () => { expect.anything(), ) }) + + it("reports a retained saved outcome from submission completion when its wakeup is lost", async () => { + let finish!: (result: { ok: boolean; remembered: boolean }) => void + submit = () => + new Promise((resolve) => { + finish = resolve + }) + const page = render(SecretUnlockDialog) + await waitFor(() => + expect(invoke).toHaveBeenCalledWith("secret_unlock_notices"), + ) + request("timed-out-save") + const input = await screen.findByLabelText("Secrets passphrase") + await fireEvent.input(input, { target: { value: "private credential" } }) + await fireEvent.click(screen.getByLabelText("Remember in OS keychain")) + await fireEvent.click(screen.getByText("Unlock and retry")) + notices = [ + { + requestId: "timed-out-save", + message: + "Saved credential after unlock timeout; use Forget to remove it.", + }, + ] + // Main timed out the unlock; the live page receives the result but no wakeup. + finish({ ok: false, remembered: true }) + await waitFor(() => + expect(toasts.info).toHaveBeenCalledExactlyOnceWith( + "Saved credential after unlock timeout; use Forget to remove it.", + { sticky: true }, + ), + ) + await waitFor(() => + expect(invoke).toHaveBeenCalledWith("secret_unlock_notice_ack", { + requestId: "timed-out-save", + }), + ) + await waitFor(() => + expect(screen.queryByLabelText("Secrets passphrase")).toBeNull(), + ) + notify() + await Promise.resolve() + expect(toasts.info).toHaveBeenCalledOnce() + expect(notices).toEqual([]) + page.unmount() + }) })