diff --git a/desktop/src/main/__tests__/ipc-secret-session.test.ts b/desktop/src/main/__tests__/ipc-secret-session.test.ts index db63cc1dd3..5664967e0e 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,364 @@ 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("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) => { @@ -521,10 +879,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 +925,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..c127546743 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,56 @@ export function registerIpcHandlers(deps: IpcDependencies): { message: "Unlock request is no longer active.", } + 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, requestId: string | undefined, @@ -420,13 +474,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 +495,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 +518,30 @@ 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.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 retainRememberedUnlockNotice(requestId) + 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 +550,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..b8483ef0d0 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("") @@ -11,9 +12,53 @@ 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 + 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 + } + } + readRememberedNotices = () => { + void reportRememberedNotices() + } + void listen("secret_unlock_notice", readRememberedNotices).then((off) => { + if (destroyed) off() + else { + unlistenNotices = off + readRememberedNotices() + } + }) void listen<{ requestId?: unknown }>("secret_unlock_required", (event) => { const nextRequestId = event.payload?.requestId if (typeof nextRequestId !== "string" || !nextRequestId.trim()) return @@ -30,7 +75,9 @@ onMount(() => { }) return () => { destroyed = true + readRememberedNotices = () => {} unlisten?.() + unlistenNotices?.() } }) async function submit() { @@ -40,17 +87,19 @@ 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.ok && result.remembered === true) readRememberedNotices() if (requestId !== submittedRequestId) return passphrase = "" - if (result.ok) { + if (result.ok || result.remembered === true) { requestId = "" open = false remember = false @@ -88,10 +137,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..b29f79d6c6 100644 --- a/desktop/src/renderer/src/lib/components/layout/SecretUnlockDialog.test.ts +++ b/desktop/src/renderer/src/lib/components/layout/SecretUnlockDialog.test.ts @@ -1,22 +1,48 @@ 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 + 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) @@ -64,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()) @@ -99,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") @@ -111,4 +135,208 @@ 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 + submit = () => + 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." + notices = [{ requestId: "remember-request", message }] + notify() + 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 + submit = () => + 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" } }) + 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( + (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 () => { + submit = async () => ({ + 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() + }) + + 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(), + ) + }) + + 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() + }) }) 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..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 @@ -423,6 +423,13 @@ 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. 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 checks sources in this order: explicit input from the invoking UI or process,