From ce0fb202a742c55cf062766680289adb8ea139ca Mon Sep 17 00:00:00 2001 From: PierrunoYT Date: Tue, 20 Oct 2026 21:41:11 +0200 Subject: [PATCH 01/30] fix(profiles): keep mode profile choices per window The mode -> provider profile map lives in shared extension storage, so a profile selected in one VS Code window leaked into subtasks and mode switches in other windows. Prefer this window's own choices and fall back to the shared map. Fixes #2109 Co-Authored-By: Claude Sonnet 5.5 --- src/core/webview/ClineProvider.ts | 28 +++++++++++++++---- .../webview/__tests__/ClineProvider.spec.ts | 15 ++++++++++ 2 files changed, 37 insertions(+), 6 deletions(-) diff --git a/src/core/webview/ClineProvider.ts b/src/core/webview/ClineProvider.ts index 28a42913f3..60806b9acd 100644 --- a/src/core/webview/ClineProvider.ts +++ b/src/core/webview/ClineProvider.ts @@ -357,6 +357,13 @@ export class ClineProvider public readonly providerSettingsManager: ProviderSettingsManager public readonly customModesManager: CustomModesManager + /** + * Mode -> profile id choices made by this window. The persisted mode map in + * `providerSettingsManager` is shared by every VS Code window, so reading it + * alone lets another window's profile selection leak into this window's tasks. + */ + private readonly localModeConfigIds = new Map() + constructor( readonly context: vscode.ExtensionContext, private readonly outputChannel: vscode.OutputChannel, @@ -1273,7 +1280,7 @@ export class ClineProvider const lockApiConfigAcrossModes = this.context.workspaceState.get("lockApiConfigAcrossModes", false) if (!historyItem.apiConfigName && !lockApiConfigAcrossModes && !skipProfileRestoreFromHistory) { - const savedConfigId = await this.providerSettingsManager.getModeConfigId(historyItem.mode) + const savedConfigId = await this.getModeConfigId(historyItem.mode) const listApiConfig = await this.providerSettingsManager.listConfig() // Update listApiConfigMeta first to ensure UI has latest data. @@ -1775,7 +1782,7 @@ export class ClineProvider if (signal?.aborted) return // Load the saved API config for the new mode if it exists. - const savedConfigId = await this.providerSettingsManager.getModeConfigId(newMode) + const savedConfigId = await this.getModeConfigId(newMode) const listApiConfig = await this.providerSettingsManager.listConfig() if (signal?.aborted) return @@ -1817,7 +1824,7 @@ export class ClineProvider const config = listApiConfig.find((c) => c.name === currentApiConfigNameAfter) if (config?.id) { - await this.providerSettingsManager.setModeConfig(newMode, config.id) + await this.setModeConfig(newMode, config.id) } } } @@ -1829,6 +1836,15 @@ export class ClineProvider // Provider Profile Management + private async getModeConfigId(mode: Mode): Promise { + return this.localModeConfigIds.get(mode) ?? (await this.providerSettingsManager.getModeConfigId(mode)) + } + + private async setModeConfig(mode: Mode, id: string): Promise { + this.localModeConfigIds.set(mode, id) + await this.providerSettingsManager.setModeConfig(mode, id) + } + /** * Updates the current task's API handler. * Rebuilds when: @@ -2034,7 +2050,7 @@ export class ClineProvider const activationResults = await Promise.allSettled([ this.updateGlobalState("listApiConfigMeta", await this.providerSettingsManager.listConfig()), this.updateGlobalState("currentApiConfigName", name), - this.providerSettingsManager.setModeConfig(mode, id), + this.setModeConfig(mode, id), this.contextProxy.setProviderSettings(providerSettings), ]) const failedActivation = activationResults.find( @@ -2156,7 +2172,7 @@ export class ClineProvider const { mode } = await this.getState() if (id && persistModeConfig) { - await this.providerSettingsManager.setModeConfig(mode, id) + await this.setModeConfig(mode, id) } // Change the provider for the current task. @@ -4007,7 +4023,7 @@ export class ClineProvider mode !== parentMode && this.context.workspaceState.get("lockApiConfigAcrossModes", false) let savedModeProfile: { name?: string; apiConfiguration: ProviderSettings } | undefined if (mode !== parentMode && !lockApiConfigAcrossModes) { - const savedConfigId = await this.providerSettingsManager.getModeConfigId(mode as Mode) + const savedConfigId = await this.getModeConfigId(mode as Mode) if (savedConfigId) { try { const { diff --git a/src/core/webview/__tests__/ClineProvider.spec.ts b/src/core/webview/__tests__/ClineProvider.spec.ts index 93543435e2..4da68d7904 100644 --- a/src/core/webview/__tests__/ClineProvider.spec.ts +++ b/src/core/webview/__tests__/ClineProvider.spec.ts @@ -2447,6 +2447,21 @@ describe("ClineProvider", () => { expect(mockContext.globalState.update).toHaveBeenCalledWith("currentApiConfigName", "test-config") }) + it("prefers this window's mode profile over one another window saved in shared storage", async () => { + await provider.resolveWebviewView(mockWebviewView) + + const manager = provider.providerSettingsManager + vi.spyOn(manager, "getModeConfigId").mockResolvedValue("other-window-id") + vi.spyOn(manager, "setModeConfig").mockResolvedValue(undefined) + + await provider["setModeConfig"]("code", "this-window-id") + + expect(manager.setModeConfig).toHaveBeenCalledWith("code", "this-window-id") + await expect(provider["getModeConfigId"]("code")).resolves.toBe("this-window-id") + // A mode this window never chose still falls back to the shared value. + await expect(provider["getModeConfigId"]("architect")).resolves.toBe("other-window-id") + }) + it("saves current config when switching to mode without config", async () => { await provider.resolveWebviewView(mockWebviewView) const messageHandler = (mockWebviewView.webview.onDidReceiveMessage as any).mock.calls[0][0] From 2724c8fef1557e9dfd877a8e8cc0edbb49e6847f Mon Sep 17 00:00:00 2001 From: PierrunoYT Date: Tue, 20 Oct 2026 21:56:29 +0200 Subject: [PATCH 02/30] test: give delegation test doubles the window-local mode lookup Co-Authored-By: Claude Sonnet 5.5 --- src/__tests__/ClineProvider.delegation.spec.ts | 10 ++++++---- 1 file changed, 6 insertions(+), 4 deletions(-) diff --git a/src/__tests__/ClineProvider.delegation.spec.ts b/src/__tests__/ClineProvider.delegation.spec.ts index 68f39c6517..fb5a5532b0 100644 --- a/src/__tests__/ClineProvider.delegation.spec.ts +++ b/src/__tests__/ClineProvider.delegation.spec.ts @@ -295,6 +295,8 @@ describe("ClineProvider.delegateParentAndOpenChild()", () => { isViewLaunched: false, taskHistoryStore: makeStoreStub(), providerSettingsManager, + // No window-local choice is recorded, so the lookup reaches the shared manager. + getModeConfigId: (mode: string) => providerSettingsManager.getModeConfigId(mode), context: { workspaceState: { get: workspaceGet } }, } as unknown as ClineProvider @@ -347,6 +349,7 @@ describe("ClineProvider.delegateParentAndOpenChild()", () => { ? vi.fn().mockRejectedValue(savedProfile) : vi.fn().mockResolvedValue(savedProfile) const log = vi.fn() + const getModeConfigId = vi.fn().mockResolvedValue(savedConfigId) const provider = { taskScheduler: new TaskScheduler(), emit: vi.fn(), @@ -356,10 +359,9 @@ describe("ClineProvider.delegateParentAndOpenChild()", () => { log, isViewLaunched: false, taskHistoryStore: makeStoreStub(), - providerSettingsManager: { - getModeConfigId: vi.fn().mockResolvedValue(savedConfigId), - getProfile, - }, + providerSettingsManager: { getModeConfigId, getProfile }, + // No window-local choice is recorded, so the lookup reaches the shared manager. + getModeConfigId, context: { workspaceState: { get: vi.fn().mockReturnValue(false) } }, } as unknown as ClineProvider From a4e06d411ae755671d951911d07298d1991668fa Mon Sep 17 00:00:00 2001 From: PierrunoYT Date: Sun, 25 Oct 2026 11:09:10 +0100 Subject: [PATCH 03/30] fix(webview): snapshot mode profile choices per window and clear them on reset Co-Authored-By: Claude Sonnet 5.5 --- .../ClineProvider.delegation.spec.ts | 47 +++++++++++++++++ src/core/config/ProviderSettingsManager.ts | 15 ++++++ .../__tests__/ProviderSettingsManager.spec.ts | 35 +++++++++++++ src/core/webview/ClineProvider.ts | 25 +++++++++- .../ClineProvider.apiHandlerRebuild.spec.ts | 2 + .../ClineProvider.lockApiConfig.spec.ts | 2 + .../webview/__tests__/ClineProvider.spec.ts | 50 +++++++++++++++++++ 7 files changed, 175 insertions(+), 1 deletion(-) diff --git a/src/__tests__/ClineProvider.delegation.spec.ts b/src/__tests__/ClineProvider.delegation.spec.ts index fb5a5532b0..7e8fc604fe 100644 --- a/src/__tests__/ClineProvider.delegation.spec.ts +++ b/src/__tests__/ClineProvider.delegation.spec.ts @@ -328,6 +328,53 @@ describe("ClineProvider.delegateParentAndOpenChild()", () => { ) }) + it("uses this window's mode profile instead of one another window saved in shared storage", async () => { + const parentTask = makeParentTask() + const createTask = vi + .fn() + .mockResolvedValue({ taskId: "child-local", run: vi.fn().mockResolvedValue(undefined) }) + const getProfile = vi.fn().mockResolvedValue({ + name: "local-profile", + id: "local-profile-id", + apiProvider: providerIdentifiers.openrouter, + openRouterModelId: "openai/gpt-4.1-mini", + }) + const sharedGetModeConfigId = vi.fn().mockResolvedValue("other-window-profile-id") + const provider = { + taskScheduler: new TaskScheduler(), + emit: vi.fn(), + getCurrentTask: vi.fn(() => parentTask), + removeClineFromStack: vi.fn().mockResolvedValue(undefined), + createTask, + log: vi.fn(), + isViewLaunched: false, + taskHistoryStore: makeStoreStub(), + providerSettingsManager: { getModeConfigId: sharedGetModeConfigId, getProfile }, + // This window's own choice differs from the shared value another window wrote. + getModeConfigId: vi.fn().mockResolvedValue("local-profile-id"), + context: { workspaceState: { get: vi.fn().mockReturnValue(false) } }, + } as unknown as ClineProvider + + await ClineProvider.prototype.delegateParentAndOpenChild.call(provider, { + parentTaskId: "parent-1", + message: "Local child", + initialTodos: [], + mode: "ask", + }) + + expect(getProfile).toHaveBeenCalledOnce() + expect(getProfile).toHaveBeenCalledWith({ id: "local-profile-id" }) + expect(sharedGetModeConfigId).not.toHaveBeenCalled() + expect(createTask).toHaveBeenCalledWith( + "Local child", + undefined, + parentTask, + expect.objectContaining({ + handoffExecutionContext: expect.objectContaining({ mode: "ask", apiConfigName: "local-profile" }), + }), + ) + }) + it.each([ { name: "has no saved mode profile", savedConfigId: undefined, savedProfile: undefined }, { diff --git a/src/core/config/ProviderSettingsManager.ts b/src/core/config/ProviderSettingsManager.ts index 01695d7994..a355b2ff01 100644 --- a/src/core/config/ProviderSettingsManager.ts +++ b/src/core/config/ProviderSettingsManager.ts @@ -574,6 +574,21 @@ export class ProviderSettingsManager { } } + /** + * Get a copy of the persisted mode -> API config ID map. The map is shared by every VS Code + * window, so callers that need a stable view must keep their own copy. + */ + public async getModeConfigIds(): Promise> { + try { + return await this.lock(async () => { + const { modeApiConfigs } = await this.load() + return { ...modeApiConfigs } + }) + } catch (error) { + throw new Error(`Failed to get mode configs: ${error}`) + } + } + public async export() { try { return await this.lock(async () => { diff --git a/src/core/config/__tests__/ProviderSettingsManager.spec.ts b/src/core/config/__tests__/ProviderSettingsManager.spec.ts index a1fc9ac7de..c77464f9f2 100644 --- a/src/core/config/__tests__/ProviderSettingsManager.spec.ts +++ b/src/core/config/__tests__/ProviderSettingsManager.spec.ts @@ -1352,6 +1352,41 @@ describe("ProviderSettingsManager", () => { }) }) + describe("GetModeConfigIds", () => { + const profilesWithModes = (modeApiConfigs?: Record) => + JSON.stringify({ + currentApiConfigName: "default", + apiConfigs: { default: { id: "default" } }, + modeApiConfigs, + migrations: { rateLimitSecondsMigrated: true }, + }) + + it("returns a copy of the stored mode map", async () => { + mockSecrets.get.mockResolvedValue(profilesWithModes({ code: "code-id", architect: "architect-id" })) + + const ids = await providerSettingsManager.getModeConfigIds() + ids.code = "changed" + + expect(ids).toEqual({ code: "changed", architect: "architect-id" }) + await expect(providerSettingsManager.getModeConfigIds()).resolves.toEqual({ + code: "code-id", + architect: "architect-id", + }) + }) + + it("returns an empty map when none is stored", async () => { + mockSecrets.get.mockResolvedValue(profilesWithModes(undefined)) + + await expect(providerSettingsManager.getModeConfigIds()).resolves.toEqual({}) + }) + + it("should throw error if secrets storage fails", async () => { + mockSecrets.get.mockRejectedValue(new Error("Storage failed")) + + await expect(providerSettingsManager.getModeConfigIds()).rejects.toThrow("Failed to get mode configs") + }) + }) + describe("HasConfig", () => { it("should return true for existing config", async () => { const existingConfig: ProviderProfiles = { diff --git a/src/core/webview/ClineProvider.ts b/src/core/webview/ClineProvider.ts index 60806b9acd..3853603568 100644 --- a/src/core/webview/ClineProvider.ts +++ b/src/core/webview/ClineProvider.ts @@ -364,6 +364,13 @@ export class ClineProvider */ private readonly localModeConfigIds = new Map() + /** + * The shared mode map as it was when this window opened. Modes this window has not changed + * resolve against it, so another window's later selection cannot reach this window's tasks + * (including delegated subtasks). + */ + private initialModeConfigIds: Promise> = Promise.resolve({}) + constructor( readonly context: vscode.ExtensionContext, private readonly outputChannel: vscode.OutputChannel, @@ -400,6 +407,7 @@ export class ClineProvider this._workspaceTracker = new WorkspaceTracker(this) this.providerSettingsManager = new ProviderSettingsManager(this.context) + this.captureInitialModeConfigIds() this.customModesManager = new CustomModesManager(this.context, async () => { await this.postStateToWebviewWithoutClineMessages() @@ -1836,8 +1844,20 @@ export class ClineProvider // Provider Profile Management + private captureInitialModeConfigIds(): void { + this.initialModeConfigIds = this.providerSettingsManager.getModeConfigIds().catch((error) => { + this.log(`Failed to snapshot mode profile choices: ${error instanceof Error ? error.message : error}`) + return {} + }) + } + private async getModeConfigId(mode: Mode): Promise { - return this.localModeConfigIds.get(mode) ?? (await this.providerSettingsManager.getModeConfigId(mode)) + return ( + this.localModeConfigIds.get(mode) ?? + (await this.initialModeConfigIds)[mode] ?? + // Modes created after this window opened have no snapshot entry. + (await this.providerSettingsManager.getModeConfigId(mode)) + ) } private async setModeConfig(mode: Mode, id: string): Promise { @@ -3396,6 +3416,9 @@ export class ClineProvider await this.contextProxy.resetAllState() await this.providerSettingsManager.resetAllConfigs() + // Cached choices point at profiles that no longer exist; re-read the reset mapping. + this.localModeConfigIds.clear() + this.captureInitialModeConfigIds() await this.customModesManager.resetCustomModes() await this.removeClineFromStack() await this.postStateToWebview() diff --git a/src/core/webview/__tests__/ClineProvider.apiHandlerRebuild.spec.ts b/src/core/webview/__tests__/ClineProvider.apiHandlerRebuild.spec.ts index 3121fe1046..8a5fdd26a4 100644 --- a/src/core/webview/__tests__/ClineProvider.apiHandlerRebuild.spec.ts +++ b/src/core/webview/__tests__/ClineProvider.apiHandlerRebuild.spec.ts @@ -240,6 +240,8 @@ describe("ClineProvider - API Handler Rebuild Guard", () => { new ContextProxy(mockContext), new WebviewFocusTracker(), ) + // These tests stub providerSettingsManager and expect it to be consulted for mode profiles. + provider["initialModeConfigIds"] = Promise.resolve({}) // Mock providerSettingsManager ;(provider as any).providerSettingsManager = { diff --git a/src/core/webview/__tests__/ClineProvider.lockApiConfig.spec.ts b/src/core/webview/__tests__/ClineProvider.lockApiConfig.spec.ts index 6472b77749..512eaf6d2a 100644 --- a/src/core/webview/__tests__/ClineProvider.lockApiConfig.spec.ts +++ b/src/core/webview/__tests__/ClineProvider.lockApiConfig.spec.ts @@ -332,6 +332,8 @@ describe("ClineProvider - Lock API Config Across Modes", () => { new ContextProxy(mockContext), new WebviewFocusTracker(), ) + // These tests stub providerSettingsManager and expect it to be consulted for mode profiles. + provider["initialModeConfigIds"] = Promise.resolve({}) // Mock getMcpHub method provider.getMcpHub = vi.fn().mockReturnValue({ diff --git a/src/core/webview/__tests__/ClineProvider.spec.ts b/src/core/webview/__tests__/ClineProvider.spec.ts index 4da68d7904..4790b243a2 100644 --- a/src/core/webview/__tests__/ClineProvider.spec.ts +++ b/src/core/webview/__tests__/ClineProvider.spec.ts @@ -552,6 +552,9 @@ describe("ClineProvider", () => { new ContextProxy(mockContext), new WebviewFocusTracker(), ) + // Most tests stub providerSettingsManager and expect it to be consulted for mode profiles, + // so start without the snapshot the real manager would take of the seeded mode map. + provider["initialModeConfigIds"] = Promise.resolve({}) defaultTaskOptions = { provider, @@ -2462,6 +2465,53 @@ describe("ClineProvider", () => { await expect(provider["getModeConfigId"]("architect")).resolves.toBe("other-window-id") }) + describe("mode profile snapshot", () => { + it("keeps the choice this window opened with when another window changes the shared value", async () => { + provider["initialModeConfigIds"] = Promise.resolve({ architect: "opened-with-id" }) + vi.spyOn(provider.providerSettingsManager, "getModeConfigId").mockResolvedValue("other-window-id") + + await expect(provider["getModeConfigId"]("architect")).resolves.toBe("opened-with-id") + // A mode created after this window opened has no snapshot entry, so the shared value applies. + await expect(provider["getModeConfigId"]("new-custom-mode")).resolves.toBe("other-window-id") + }) + + it("prefers an explicit local choice over the snapshot", async () => { + provider["initialModeConfigIds"] = Promise.resolve({ architect: "opened-with-id" }) + vi.spyOn(provider.providerSettingsManager, "setModeConfig").mockResolvedValue(undefined) + + await provider["setModeConfig"]("architect", "chosen-id") + + await expect(provider["getModeConfigId"]("architect")).resolves.toBe("chosen-id") + }) + + it("falls back to the shared value when the snapshot cannot be read", async () => { + vi.spyOn(provider.providerSettingsManager, "getModeConfigIds").mockRejectedValue(new Error("unreadable")) + vi.spyOn(provider.providerSettingsManager, "getModeConfigId").mockResolvedValue("shared-id") + + provider["captureInitialModeConfigIds"]() + + await expect(provider["getModeConfigId"]("architect")).resolves.toBe("shared-id") + }) + + it("drops local choices and re-reads the mapping when state is reset", async () => { + const { t } = await import("../../../i18n") + vi.mocked(vscode.window.showInformationMessage).mockResolvedValueOnce(t("common:answers.yes") as never) + vi.spyOn(provider.providerSettingsManager, "setModeConfig").mockResolvedValue(undefined) + vi.spyOn(provider.providerSettingsManager, "resetAllConfigs").mockResolvedValue(undefined) + vi.spyOn(provider.contextProxy, "resetAllState").mockResolvedValue(undefined) + // The shared custom-modes mock does not implement reset. + Object.assign(provider.customModesManager, { resetCustomModes: vi.fn().mockResolvedValue(undefined) }) + vi.spyOn(provider, "postStateToWebview").mockResolvedValue(undefined) + vi.spyOn(provider.providerSettingsManager, "getModeConfigIds").mockResolvedValue({ code: "reset-id" }) + vi.spyOn(provider.providerSettingsManager, "getModeConfigId").mockResolvedValue(undefined) + await provider["setModeConfig"]("code", "removed-profile-id") + + await provider.resetState() + + await expect(provider["getModeConfigId"]("code")).resolves.toBe("reset-id") + }) + }) + it("saves current config when switching to mode without config", async () => { await provider.resolveWebviewView(mockWebviewView) const messageHandler = (mockWebviewView.webview.onDidReceiveMessage as any).mock.calls[0][0] From ed2416c18414e0013cc3d88a4f5b1a97377a2527 Mon Sep 17 00:00:00 2001 From: PierrunoYT Date: Wed, 4 Nov 2026 15:41:23 +0100 Subject: [PATCH 04/30] fix(profiles): keep unseen modes window-local, drop stale choices, roll back failed writes --- src/core/webview/ClineProvider.ts | 44 +++++++++--- .../ClineProvider.apiHandlerRebuild.spec.ts | 4 +- .../ClineProvider.lockApiConfig.spec.ts | 4 +- .../webview/__tests__/ClineProvider.spec.ts | 69 ++++++++++++++----- 4 files changed, 91 insertions(+), 30 deletions(-) diff --git a/src/core/webview/ClineProvider.ts b/src/core/webview/ClineProvider.ts index 8b8a7087af..42b9755665 100644 --- a/src/core/webview/ClineProvider.ts +++ b/src/core/webview/ClineProvider.ts @@ -430,9 +430,9 @@ export class ClineProvider /** * The shared mode map as it was when this window opened. Modes this window has not changed * resolve against it, so another window's later selection cannot reach this window's tasks - * (including delegated subtasks). + * (including delegated subtasks). `undefined` when the map could not be read. */ - private initialModeConfigIds: Promise> = Promise.resolve({}) + private initialModeConfigIds: Promise | undefined> = Promise.resolve({}) constructor( readonly context: vscode.ExtensionContext, @@ -2169,22 +2169,46 @@ export class ClineProvider private captureInitialModeConfigIds(): void { this.initialModeConfigIds = this.providerSettingsManager.getModeConfigIds().catch((error) => { this.log(`Failed to snapshot mode profile choices: ${error instanceof Error ? error.message : error}`) - return {} + return undefined }) } + /** + * Resolve the profile id for `mode` from this window's own view: its explicit choices, then the + * shared map as it was when the window opened. Modes absent from both resolve to `undefined`, so + * callers keep this window's current profile instead of one another window saved later. A cached + * id whose profile no longer exists (e.g. after a reset) is dropped in favour of the shared map, + * which is also used when the opening snapshot could not be read. + */ private async getModeConfigId(mode: Mode): Promise { - return ( - this.localModeConfigIds.get(mode) ?? - (await this.initialModeConfigIds)[mode] ?? - // Modes created after this window opened have no snapshot entry. - (await this.providerSettingsManager.getModeConfigId(mode)) - ) + const localId = this.localModeConfigIds.get(mode) + const initialIds = localId === undefined ? await this.initialModeConfigIds : undefined + if (localId === undefined && initialIds === undefined) { + return this.providerSettingsManager.getModeConfigId(mode) + } + const cachedId = localId ?? initialIds?.[mode] + if (cachedId === undefined) return undefined + + const profiles = await this.providerSettingsManager.listConfig() + if (profiles.some(({ id }) => id === cachedId)) return cachedId + + if (localId !== undefined) this.localModeConfigIds.delete(mode) + return this.providerSettingsManager.getModeConfigId(mode) } private async setModeConfig(mode: Mode, id: string): Promise { + const previousId = this.localModeConfigIds.get(mode) this.localModeConfigIds.set(mode, id) - await this.providerSettingsManager.setModeConfig(mode, id) + try { + await this.providerSettingsManager.setModeConfig(mode, id) + } catch (error) { + // Keep this window consistent with the shared map the failed write left unchanged. + if (this.localModeConfigIds.get(mode) === id) { + if (previousId === undefined) this.localModeConfigIds.delete(mode) + else this.localModeConfigIds.set(mode, previousId) + } + throw error + } } /** diff --git a/src/core/webview/__tests__/ClineProvider.apiHandlerRebuild.spec.ts b/src/core/webview/__tests__/ClineProvider.apiHandlerRebuild.spec.ts index 3d8beb72fa..8fb0504c33 100644 --- a/src/core/webview/__tests__/ClineProvider.apiHandlerRebuild.spec.ts +++ b/src/core/webview/__tests__/ClineProvider.apiHandlerRebuild.spec.ts @@ -239,8 +239,8 @@ describe("ClineProvider - API Handler Rebuild Guard", () => { new ContextProxy(mockContext), new WebviewFocusTracker(), ) - // These tests stub providerSettingsManager and expect it to be consulted for mode profiles. - provider["initialModeConfigIds"] = Promise.resolve({}) + // These tests stub providerSettingsManager; without an opening snapshot, mode lookups read it. + provider["initialModeConfigIds"] = Promise.resolve(undefined) // Mock providerSettingsManager ;(provider as any).providerSettingsManager = { diff --git a/src/core/webview/__tests__/ClineProvider.lockApiConfig.spec.ts b/src/core/webview/__tests__/ClineProvider.lockApiConfig.spec.ts index 62514466cb..6e22e35902 100644 --- a/src/core/webview/__tests__/ClineProvider.lockApiConfig.spec.ts +++ b/src/core/webview/__tests__/ClineProvider.lockApiConfig.spec.ts @@ -331,8 +331,8 @@ describe("ClineProvider - Lock API Config Across Modes", () => { new ContextProxy(mockContext), new WebviewFocusTracker(), ) - // These tests stub providerSettingsManager and expect it to be consulted for mode profiles. - provider["initialModeConfigIds"] = Promise.resolve({}) + // These tests stub providerSettingsManager; without an opening snapshot, mode lookups read it. + provider["initialModeConfigIds"] = Promise.resolve(undefined) // Mock getMcpHub method provider.getMcpHub = vi.fn().mockReturnValue({ diff --git a/src/core/webview/__tests__/ClineProvider.spec.ts b/src/core/webview/__tests__/ClineProvider.spec.ts index 8bf4ea5c9d..b702a0de2e 100644 --- a/src/core/webview/__tests__/ClineProvider.spec.ts +++ b/src/core/webview/__tests__/ClineProvider.spec.ts @@ -560,7 +560,7 @@ describe("ClineProvider", () => { ) // Most tests stub providerSettingsManager and expect it to be consulted for mode profiles, // so start without the snapshot the real manager would take of the seeded mode map. - provider["initialModeConfigIds"] = Promise.resolve({}) + provider["initialModeConfigIds"] = Promise.resolve(undefined) defaultTaskOptions = { provider, @@ -4481,33 +4481,41 @@ describe("ClineProvider", () => { expect(mockContext.globalState.update).toHaveBeenCalledWith("currentApiConfigName", "test-config") }) - it("prefers this window's mode profile over one another window saved in shared storage", async () => { - await provider.resolveWebviewView(mockWebviewView) + describe("mode profile choices", () => { + const existingProfiles = (...ids: string[]) => + vi + .spyOn(provider.providerSettingsManager, "listConfig") + .mockResolvedValue(ids.map((id) => ({ name: `${id}-name`, id }))) - const manager = provider.providerSettingsManager - vi.spyOn(manager, "getModeConfigId").mockResolvedValue("other-window-id") - vi.spyOn(manager, "setModeConfig").mockResolvedValue(undefined) + it("prefers this window's mode profile over one another window saved in shared storage", async () => { + const manager = provider.providerSettingsManager + existingProfiles("this-window-id", "other-window-id") + vi.spyOn(manager, "getModeConfigId").mockResolvedValue("other-window-id") + vi.spyOn(manager, "setModeConfig").mockResolvedValue(undefined) - await provider["setModeConfig"]("code", "this-window-id") + await provider["setModeConfig"]("code", "this-window-id") - expect(manager.setModeConfig).toHaveBeenCalledWith("code", "this-window-id") - await expect(provider["getModeConfigId"]("code")).resolves.toBe("this-window-id") - // A mode this window never chose still falls back to the shared value. - await expect(provider["getModeConfigId"]("architect")).resolves.toBe("other-window-id") - }) + expect(manager.setModeConfig).toHaveBeenCalledWith("code", "this-window-id") + await expect(provider["getModeConfigId"]("code")).resolves.toBe("this-window-id") + }) - describe("mode profile snapshot", () => { it("keeps the choice this window opened with when another window changes the shared value", async () => { provider["initialModeConfigIds"] = Promise.resolve({ architect: "opened-with-id" }) - vi.spyOn(provider.providerSettingsManager, "getModeConfigId").mockResolvedValue("other-window-id") + existingProfiles("opened-with-id", "other-window-id") + const sharedLookup = vi + .spyOn(provider.providerSettingsManager, "getModeConfigId") + .mockResolvedValue("other-window-id") await expect(provider["getModeConfigId"]("architect")).resolves.toBe("opened-with-id") - // A mode created after this window opened has no snapshot entry, so the shared value applies. - await expect(provider["getModeConfigId"]("new-custom-mode")).resolves.toBe("other-window-id") + // A mode absent when this window opened keeps this window's current profile instead of + // one another window saved for it later. + await expect(provider["getModeConfigId"]("new-custom-mode")).resolves.toBeUndefined() + expect(sharedLookup).not.toHaveBeenCalled() }) it("prefers an explicit local choice over the snapshot", async () => { provider["initialModeConfigIds"] = Promise.resolve({ architect: "opened-with-id" }) + existingProfiles("opened-with-id", "chosen-id") vi.spyOn(provider.providerSettingsManager, "setModeConfig").mockResolvedValue(undefined) await provider["setModeConfig"]("architect", "chosen-id") @@ -4524,6 +4532,34 @@ describe("ClineProvider", () => { await expect(provider["getModeConfigId"]("architect")).resolves.toBe("shared-id") }) + it("drops a local choice whose profile was removed and falls back to the shared mapping", async () => { + provider["initialModeConfigIds"] = Promise.resolve({}) + vi.spyOn(provider.providerSettingsManager, "setModeConfig").mockResolvedValue(undefined) + vi.spyOn(provider.providerSettingsManager, "getModeConfigId").mockResolvedValue("shared-id") + await provider["setModeConfig"]("code", "removed-id") + // Another window reset or deleted the profile this window chose. + existingProfiles("shared-id") + + await expect(provider["getModeConfigId"]("code")).resolves.toBe("shared-id") + expect(provider["localModeConfigIds"].has("code")).toBe(false) + }) + + it("restores the previous local choice when the shared write fails", async () => { + provider["initialModeConfigIds"] = Promise.resolve({}) + existingProfiles("first-id", "second-id") + const sharedWrite = vi.spyOn(provider.providerSettingsManager, "setModeConfig") + sharedWrite.mockResolvedValueOnce(undefined) + await provider["setModeConfig"]("code", "first-id") + + sharedWrite.mockRejectedValueOnce(new Error("write failed")) + await expect(provider["setModeConfig"]("code", "second-id")).rejects.toThrow("write failed") + await expect(provider["getModeConfigId"]("code")).resolves.toBe("first-id") + + sharedWrite.mockRejectedValueOnce(new Error("write failed")) + await expect(provider["setModeConfig"]("architect", "second-id")).rejects.toThrow("write failed") + await expect(provider["getModeConfigId"]("architect")).resolves.toBeUndefined() + }) + it("drops local choices and re-reads the mapping when state is reset", async () => { const { t } = await import("../../../i18n") vi.mocked(vscode.window.showInformationMessage).mockResolvedValueOnce(t("common:answers.yes") as never) @@ -4535,6 +4571,7 @@ describe("ClineProvider", () => { vi.spyOn(provider, "postStateToWebview").mockResolvedValue(undefined) vi.spyOn(provider.providerSettingsManager, "getModeConfigIds").mockResolvedValue({ code: "reset-id" }) vi.spyOn(provider.providerSettingsManager, "getModeConfigId").mockResolvedValue(undefined) + existingProfiles("removed-profile-id", "reset-id") await provider["setModeConfig"]("code", "removed-profile-id") await provider.resetState() From 4ba97ac716867e0fe64f3f997b4f67e302e61423 Mon Sep 17 00:00:00 2001 From: Elliott de Launay Date: Sat, 7 Nov 2026 15:37:03 +0000 Subject: [PATCH 05/30] fix: preserve window-local mode defaults after imports and API updates --- .../config/__tests__/importExport.spec.ts | 28 +++++++++++++++++++ src/core/config/importExport.ts | 24 +++++++++++++--- src/core/webview/ClineProvider.ts | 9 +++++- .../webview/__tests__/ClineProvider.spec.ts | 13 +++++++++ src/extension.ts | 1 + .../__tests__/api-configuration.spec.ts | 26 +++++++++++++---- src/extension/api.ts | 2 +- src/utils/autoImportSettings.ts | 3 +- 8 files changed, 94 insertions(+), 12 deletions(-) diff --git a/src/core/config/__tests__/importExport.spec.ts b/src/core/config/__tests__/importExport.spec.ts index 6c66655325..de654db60c 100644 --- a/src/core/config/__tests__/importExport.spec.ts +++ b/src/core/config/__tests__/importExport.spec.ts @@ -194,6 +194,29 @@ describe("importExport", () => { mockContextProxy.setProviderSettings.mockResolvedValue(undefined) }) + it.each([false, true])( + "updates the importing window only after successful persistence (failure: %s)", + async (fails) => { + const modeApiConfigs = { "new-custom-mode": "test-id" } + const file = JSON.parse(validFileContent) + file.providerProfiles.modeApiConfigs = modeApiConfigs + vi.mocked(fs.readFile).mockResolvedValue(JSON.stringify(file)) + const onModeConfigIdsImported = vi.fn() + if (fails) mockProviderSettingsManager.import.mockRejectedValueOnce(new Error("write failed")) + + const result = await importSettingsFromPath("/mock/path/settings.json", { + providerSettingsManager: mockProviderSettingsManager, + contextProxy: mockContextProxy, + customModesManager: mockCustomModesManager, + onModeConfigIdsImported, + }) + + expect(result.success).toBe(!fails) + if (fails) expect(onModeConfigIdsImported).not.toHaveBeenCalled() + else expect(onModeConfigIdsImported).toHaveBeenCalledExactlyOnceWith(modeApiConfigs) + }, + ) + it("waits for each provider-state write before reporting success", async () => { const currentProfileWrite = createDeferred() const providerSettingsWrite = createDeferred() @@ -638,6 +661,7 @@ describe("importExport", () => { // Create a mock provider for the test const mockProvider = { settingsImportedAt: 0, + adoptModeConfigIds: vi.fn(), postStateToWebview: vi.fn().mockResolvedValue(undefined), postStateToWebviewWithoutTaskHistory: vi.fn().mockResolvedValue(undefined), } @@ -921,6 +945,7 @@ describe("importExport", () => { const seenImportedAt: Array = [] const mockProvider = { settingsImportedAt: undefined as number | undefined, + adoptModeConfigIds: vi.fn(), postStateToWebview: vi.fn().mockImplementation(async () => { seenImportedAt.push(mockProvider.settingsImportedAt) }), @@ -997,6 +1022,7 @@ describe("importExport", () => { const seenImportedAt: Array = [] const mockProvider = { settingsImportedAt: undefined as number | undefined, + adoptModeConfigIds: vi.fn(), postStateToWebview: vi.fn().mockImplementation(async () => { seenImportedAt.push(mockProvider.settingsImportedAt) }), @@ -1268,6 +1294,7 @@ describe("importExport", () => { const mockProvider = { settingsImportedAt: 0, + adoptModeConfigIds: vi.fn(), postStateToWebview: vi.fn().mockResolvedValue(undefined), } @@ -1537,6 +1564,7 @@ describe("importExport", () => { const mockProvider = { settingsImportedAt: 0, + adoptModeConfigIds: vi.fn(), postStateToWebview: vi.fn().mockResolvedValue(undefined), } diff --git a/src/core/config/importExport.ts b/src/core/config/importExport.ts index 9882039ad3..df9281804d 100644 --- a/src/core/config/importExport.ts +++ b/src/core/config/importExport.ts @@ -27,6 +27,7 @@ export type ImportOptions = { providerSettingsManager: ProviderSettingsManager contextProxy: ContextProxy customModesManager: CustomModesManager + onModeConfigIdsImported?: (ids: Record) => void } type ExportOptions = { @@ -37,6 +38,7 @@ type ImportWithProviderOptions = ImportOptions & { provider: { settingsImportedAt?: number postStateToWebview: () => Promise + adoptModeConfigIds: (ids: Record) => void } } @@ -135,7 +137,7 @@ function sanitizeGlobalSettings(rawGlobalSettings: unknown): { */ export async function importSettingsFromPath( filePath: string, - { providerSettingsManager, contextProxy, customModesManager }: ImportOptions, + { providerSettingsManager, contextProxy, customModesManager, onModeConfigIdsImported }: ImportOptions, ) { // Use a lenient schema that accepts any apiConfigs, then validate each individually const lenientProviderProfilesSchema = providerProfilesSchema.extend({ @@ -228,6 +230,7 @@ export async function importSettingsFromPath( // They will be imported automatically with the config - no special handling needed await providerSettingsManager.import(providerProfiles) + onModeConfigIdsImported?.(rawProviderProfiles.modeApiConfigs ?? {}) await contextProxy.setValues(sanitizedGlobalSettings) // Set the current provider. @@ -269,7 +272,12 @@ export async function importSettingsFromPath( * @param options - Import options containing managers and proxy * @returns Promise resolving to import result */ -export const importSettings = async ({ providerSettingsManager, contextProxy, customModesManager }: ImportOptions) => { +export const importSettings = async ({ + providerSettingsManager, + contextProxy, + customModesManager, + onModeConfigIdsImported, +}: ImportOptions) => { // Use the last export path as a sensible default, falling back to Downloads const defaultUri = resolveDefaultSaveUri(contextProxy, "lastSettingsExportPath", "zoo-code-settings.json", { useWorkspace: false, @@ -290,6 +298,7 @@ export const importSettings = async ({ providerSettingsManager, contextProxy, cu providerSettingsManager, contextProxy, customModesManager, + onModeConfigIdsImported, }) } @@ -302,13 +311,14 @@ export const importSettings = async ({ providerSettingsManager, contextProxy, cu * @returns Promise resolving to import result */ export const importSettingsFromFile = async ( - { providerSettingsManager, contextProxy, customModesManager }: ImportOptions, + { providerSettingsManager, contextProxy, customModesManager, onModeConfigIdsImported }: ImportOptions, fileUri: vscode.Uri, ) => { return importSettingsFromPath(fileUri.fsPath, { providerSettingsManager, contextProxy, customModesManager, + onModeConfigIdsImported, }) } @@ -374,6 +384,7 @@ export const importSettingsWithFeedback = async ( providerSettingsManager, contextProxy, customModesManager, + onModeConfigIdsImported: (ids) => provider.adoptModeConfigIds(ids), }) } catch (error) { result = { @@ -382,7 +393,12 @@ export const importSettingsWithFeedback = async ( } } } else { - result = await importSettings({ providerSettingsManager, contextProxy, customModesManager }) + result = await importSettings({ + providerSettingsManager, + contextProxy, + customModesManager, + onModeConfigIdsImported: (ids) => provider.adoptModeConfigIds(ids), + }) } if (result.success) { diff --git a/src/core/webview/ClineProvider.ts b/src/core/webview/ClineProvider.ts index 42b9755665..cd6a8789ad 100644 --- a/src/core/webview/ClineProvider.ts +++ b/src/core/webview/ClineProvider.ts @@ -2196,7 +2196,14 @@ export class ClineProvider return this.providerSettingsManager.getModeConfigId(mode) } - private async setModeConfig(mode: Mode, id: string): Promise { + /** Adopt only mappings explicitly written by an import in this window. */ + public adoptModeConfigIds(ids: Record): void { + for (const [mode, id] of Object.entries(ids)) { + this.localModeConfigIds.set(mode, id) + } + } + + public async setModeConfig(mode: Mode, id: string): Promise { const previousId = this.localModeConfigIds.get(mode) this.localModeConfigIds.set(mode, id) try { diff --git a/src/core/webview/__tests__/ClineProvider.spec.ts b/src/core/webview/__tests__/ClineProvider.spec.ts index b702a0de2e..9aca6f1eb9 100644 --- a/src/core/webview/__tests__/ClineProvider.spec.ts +++ b/src/core/webview/__tests__/ClineProvider.spec.ts @@ -4523,6 +4523,19 @@ describe("ClineProvider", () => { await expect(provider["getModeConfigId"]("architect")).resolves.toBe("chosen-id") }) + it.each(["architect", "new-custom-mode"])( + "adopts imported defaults for %s without adopting other windows' writes", + async (mode) => { + provider["initialModeConfigIds"] = Promise.resolve({ architect: "opened-with-id" }) + existingProfiles("opened-with-id", "imported-id", "other-window-id") + vi.spyOn(provider.providerSettingsManager, "getModeConfigId").mockResolvedValue("other-window-id") + provider.adoptModeConfigIds({ [mode]: "imported-id" }) + + await expect(provider["getModeConfigId"](mode)).resolves.toBe("imported-id") + await expect(provider["getModeConfigId"]("unrelated-mode")).resolves.toBeUndefined() + }, + ) + it("falls back to the shared value when the snapshot cannot be read", async () => { vi.spyOn(provider.providerSettingsManager, "getModeConfigIds").mockRejectedValue(new Error("unreadable")) vi.spyOn(provider.providerSettingsManager, "getModeConfigId").mockResolvedValue("shared-id") diff --git a/src/extension.ts b/src/extension.ts index 6ce42aacd5..07f6089a03 100644 --- a/src/extension.ts +++ b/src/extension.ts @@ -283,6 +283,7 @@ export async function activate(context: vscode.ExtensionContext) { providerSettingsManager: provider.providerSettingsManager, contextProxy: provider.contextProxy, customModesManager: provider.customModesManager, + onModeConfigIdsImported: (ids) => provider.adoptModeConfigIds(ids), }) } catch (error) { outputChannel.appendLine( diff --git a/src/extension/__tests__/api-configuration.spec.ts b/src/extension/__tests__/api-configuration.spec.ts index f4ed8af469..3b19fc0f2c 100644 --- a/src/extension/__tests__/api-configuration.spec.ts +++ b/src/extension/__tests__/api-configuration.spec.ts @@ -2,7 +2,7 @@ import { describe, expect, it, vi } from "vitest" import type * as vscode from "vscode" import { API } from "../api" -import type { ClineProvider } from "../../core/webview/ClineProvider" +import { ClineProvider } from "../../core/webview/ClineProvider" import { makeClineProviderFactory } from "../../test-utils/provider" vi.mock("@roo-code/ipc", () => ({ @@ -19,15 +19,27 @@ describe("API - configuration", () => { context: {}, on: vi.fn(), contextProxy: { setValues }, - providerSettingsManager: { saveConfig, setModeConfig }, + providerSettingsManager: { + saveConfig, + setModeConfig, + listConfig: vi.fn().mockResolvedValue([ + { name: "code", id: "code-config" }, + { name: "custom", id: "architect-config" }, + ]), + }, + localModeConfigIds: new Map(), + initialModeConfigIds: Promise.resolve({}), + setModeConfig: ClineProvider.prototype.setModeConfig, + getModeConfigId: ClineProvider.prototype["getModeConfigId"], postStateToWebview, + // Provides the configuration methods and event registration used by API. } as unknown as ClineProvider const outputChannel = { appendLine: vi.fn() } as unknown as vscode.OutputChannel const api = new API(outputChannel, provider, makeClineProviderFactory()) await api.setConfiguration({ currentApiConfigName: "default", - modeApiConfigs: { code: "code-config", architect: "architect-config" }, + modeApiConfigs: { code: "code-config", "new-custom-mode": "architect-config" }, }) expect(saveConfig).toHaveBeenCalledWith("default", expect.objectContaining({ currentApiConfigName: "default" })) @@ -39,7 +51,9 @@ describe("API - configuration", () => { ) expect(setModeConfig).toHaveBeenCalledTimes(2) expect(setModeConfig).toHaveBeenCalledWith("code", "code-config") - expect(setModeConfig).toHaveBeenCalledWith("architect", "architect-config") + expect(setModeConfig).toHaveBeenCalledWith("new-custom-mode", "architect-config") + await expect(provider["getModeConfigId"]("code")).resolves.toBe("code-config") + await expect(provider["getModeConfigId"]("new-custom-mode")).resolves.toBe("architect-config") expect(postStateToWebview).toHaveBeenCalledOnce() }) @@ -52,8 +66,10 @@ describe("API - configuration", () => { context: {}, on: vi.fn(), contextProxy: { setValues }, - providerSettingsManager: { saveConfig, setModeConfig }, + providerSettingsManager: { saveConfig }, + setModeConfig, postStateToWebview, + // Provides the configuration methods and event registration used by API. } as unknown as ClineProvider const outputChannel = { appendLine: vi.fn() } as unknown as vscode.OutputChannel const api = new API(outputChannel, provider, makeClineProviderFactory()) diff --git a/src/extension/api.ts b/src/extension/api.ts index da59c48b58..60110919a7 100644 --- a/src/extension/api.ts +++ b/src/extension/api.ts @@ -634,7 +634,7 @@ export class API extends EventEmitter implements RooCodeAPI { if (values.modeApiConfigs) { await Promise.all( Object.entries(values.modeApiConfigs).map(([mode, configId]) => - this.sidebarProvider.providerSettingsManager.setModeConfig(mode as Mode, configId), + this.sidebarProvider.setModeConfig(mode as Mode, configId), ), ) } diff --git a/src/utils/autoImportSettings.ts b/src/utils/autoImportSettings.ts index 3c8773fb6b..511bec72c3 100644 --- a/src/utils/autoImportSettings.ts +++ b/src/utils/autoImportSettings.ts @@ -15,7 +15,7 @@ import { importSettingsFromPath, ImportOptions } from "../core/config/importExpo */ export async function autoImportSettings( outputChannel: vscode.OutputChannel, - { providerSettingsManager, contextProxy, customModesManager }: ImportOptions, + { providerSettingsManager, contextProxy, customModesManager, onModeConfigIdsImported }: ImportOptions, ): Promise { try { // Get the auto-import settings path from VSCode settings @@ -41,6 +41,7 @@ export async function autoImportSettings( providerSettingsManager, contextProxy, customModesManager, + onModeConfigIdsImported, }) if (result.success) { From 19d3b3c2b7e336ac35271b8db0f4db72b0fdab0a Mon Sep 17 00:00:00 2001 From: Elliott de Launay Date: Mon, 9 Nov 2026 05:26:33 +0000 Subject: [PATCH 06/30] fix: preserve newer local profile choices during stale ID cleanup --- src/core/webview/ClineProvider.ts | 3 ++ .../webview/__tests__/ClineProvider.spec.ts | 36 +++++++++++++++++++ 2 files changed, 39 insertions(+) diff --git a/src/core/webview/ClineProvider.ts b/src/core/webview/ClineProvider.ts index cd6a8789ad..3762b67ce2 100644 --- a/src/core/webview/ClineProvider.ts +++ b/src/core/webview/ClineProvider.ts @@ -2183,6 +2183,7 @@ export class ClineProvider private async getModeConfigId(mode: Mode): Promise { const localId = this.localModeConfigIds.get(mode) const initialIds = localId === undefined ? await this.initialModeConfigIds : undefined + if (this.localModeConfigIds.get(mode) !== localId) return this.getModeConfigId(mode) if (localId === undefined && initialIds === undefined) { return this.providerSettingsManager.getModeConfigId(mode) } @@ -2190,6 +2191,8 @@ export class ClineProvider if (cachedId === undefined) return undefined const profiles = await this.providerSettingsManager.listConfig() + // A profile selection may have changed while either asynchronous read was pending. + if (this.localModeConfigIds.get(mode) !== localId) return this.getModeConfigId(mode) if (profiles.some(({ id }) => id === cachedId)) return cachedId if (localId !== undefined) this.localModeConfigIds.delete(mode) diff --git a/src/core/webview/__tests__/ClineProvider.spec.ts b/src/core/webview/__tests__/ClineProvider.spec.ts index 9aca6f1eb9..0baa61a23f 100644 --- a/src/core/webview/__tests__/ClineProvider.spec.ts +++ b/src/core/webview/__tests__/ClineProvider.spec.ts @@ -4557,6 +4557,42 @@ describe("ClineProvider", () => { expect(provider["localModeConfigIds"].has("code")).toBe(false) }) + it.each(["removed-id", "existing-id"])( + "preserves a newer local choice while validating %s", + async (previousId) => { + provider["initialModeConfigIds"] = Promise.resolve({ code: "opened-with-id" }) + vi.spyOn(provider.providerSettingsManager, "setModeConfig").mockResolvedValue(undefined) + const sharedLookup = vi + .spyOn(provider.providerSettingsManager, "getModeConfigId") + .mockResolvedValue("other-window-id") + await provider.setModeConfig("code", previousId) + let releaseLookup = () => {} + const pendingLookup = new Promise((resolve) => { + releaseLookup = resolve + }) + const profiles = [ + { name: "existing", id: "existing-id" }, + { name: "new", id: "new-id" }, + ] + const listConfig = vi.spyOn(provider.providerSettingsManager, "listConfig") + listConfig + .mockImplementationOnce(async () => { + await pendingLookup + return profiles + }) + .mockResolvedValue(profiles) + + const lookup = provider["getModeConfigId"]("code") + expect(listConfig).toHaveBeenCalledOnce() + await provider.setModeConfig("code", "new-id") + releaseLookup() + + await expect(lookup).resolves.toBe("new-id") + await expect(provider["getModeConfigId"]("code")).resolves.toBe("new-id") + expect(sharedLookup).not.toHaveBeenCalled() + }, + ) + it("restores the previous local choice when the shared write fails", async () => { provider["initialModeConfigIds"] = Promise.resolve({}) existingProfiles("first-id", "second-id") From 6edefcec7d0d37ed576bb0fb19b1304b4edf3768 Mon Sep 17 00:00:00 2001 From: Elliott de Launay Date: Mon, 9 Nov 2026 23:14:18 +0000 Subject: [PATCH 07/30] test: cover mode profile selection during pending snapshot --- .../webview/__tests__/ClineProvider.spec.ts | 19 +++++++++++++++++++ 1 file changed, 19 insertions(+) diff --git a/src/core/webview/__tests__/ClineProvider.spec.ts b/src/core/webview/__tests__/ClineProvider.spec.ts index 0baa61a23f..a828e64497 100644 --- a/src/core/webview/__tests__/ClineProvider.spec.ts +++ b/src/core/webview/__tests__/ClineProvider.spec.ts @@ -4557,6 +4557,25 @@ describe("ClineProvider", () => { expect(provider["localModeConfigIds"].has("code")).toBe(false) }) + it("preserves a local choice made while the initial snapshot is pending", async () => { + let resolveSnapshot = (_ids: Record) => {} + provider["initialModeConfigIds"] = new Promise>((resolve) => { + resolveSnapshot = resolve + }) + existingProfiles("new-id") + vi.spyOn(provider.providerSettingsManager, "setModeConfig").mockResolvedValue(undefined) + const sharedLookup = vi + .spyOn(provider.providerSettingsManager, "getModeConfigId") + .mockResolvedValue("other-window-id") + + const lookup = provider["getModeConfigId"]("code") + await provider.setModeConfig("code", "new-id") + resolveSnapshot({}) + + await expect(lookup).resolves.toBe("new-id") + expect(sharedLookup).not.toHaveBeenCalled() + }) + it.each(["removed-id", "existing-id"])( "preserves a newer local choice while validating %s", async (previousId) => { From 68160ec694a567499f3ca89ee3218c0337c6338c Mon Sep 17 00:00:00 2001 From: Elliott de Launay Date: Tue, 10 Nov 2026 00:22:19 +0000 Subject: [PATCH 08/30] fix: isolate mode profiles on snapshot failure and serialize writes --- src/core/webview/ClineProvider.ts | 23 +++++++-- .../ClineProvider.apiHandlerRebuild.spec.ts | 5 +- .../ClineProvider.lockApiConfig.spec.ts | 7 +-- .../webview/__tests__/ClineProvider.spec.ts | 47 ++++++++++++++++--- .../__tests__/api-configuration.spec.ts | 2 + 5 files changed, 68 insertions(+), 16 deletions(-) diff --git a/src/core/webview/ClineProvider.ts b/src/core/webview/ClineProvider.ts index 3762b67ce2..3d46f26e02 100644 --- a/src/core/webview/ClineProvider.ts +++ b/src/core/webview/ClineProvider.ts @@ -434,6 +434,9 @@ export class ClineProvider */ private initialModeConfigIds: Promise | undefined> = Promise.resolve({}) + /** Serialize each mode’s local choice and persisted write, including failure rollback. */ + private readonly modeConfigWrites = new Map>() + constructor( readonly context: vscode.ExtensionContext, private readonly outputChannel: vscode.OutputChannel, @@ -2178,15 +2181,12 @@ export class ClineProvider * shared map as it was when the window opened. Modes absent from both resolve to `undefined`, so * callers keep this window's current profile instead of one another window saved later. A cached * id whose profile no longer exists (e.g. after a reset) is dropped in favour of the shared map, - * which is also used when the opening snapshot could not be read. + * while an unreadable opening snapshot keeps this window’s current profile. */ private async getModeConfigId(mode: Mode): Promise { const localId = this.localModeConfigIds.get(mode) const initialIds = localId === undefined ? await this.initialModeConfigIds : undefined if (this.localModeConfigIds.get(mode) !== localId) return this.getModeConfigId(mode) - if (localId === undefined && initialIds === undefined) { - return this.providerSettingsManager.getModeConfigId(mode) - } const cachedId = localId ?? initialIds?.[mode] if (cachedId === undefined) return undefined @@ -2207,6 +2207,21 @@ export class ClineProvider } public async setModeConfig(mode: Mode, id: string): Promise { + const pending = this.modeConfigWrites.get(mode) + const write = (async () => { + // A failed predecessor must roll back before this operation captures its previous choice. + if (pending) await pending.catch(() => {}) + await this.writeModeConfig(mode, id) + })() + this.modeConfigWrites.set(mode, write) + try { + await write + } finally { + if (this.modeConfigWrites.get(mode) === write) this.modeConfigWrites.delete(mode) + } + } + + private async writeModeConfig(mode: Mode, id: string): Promise { const previousId = this.localModeConfigIds.get(mode) this.localModeConfigIds.set(mode, id) try { diff --git a/src/core/webview/__tests__/ClineProvider.apiHandlerRebuild.spec.ts b/src/core/webview/__tests__/ClineProvider.apiHandlerRebuild.spec.ts index 8fb0504c33..ca504be775 100644 --- a/src/core/webview/__tests__/ClineProvider.apiHandlerRebuild.spec.ts +++ b/src/core/webview/__tests__/ClineProvider.apiHandlerRebuild.spec.ts @@ -239,8 +239,8 @@ describe("ClineProvider - API Handler Rebuild Guard", () => { new ContextProxy(mockContext), new WebviewFocusTracker(), ) - // These tests stub providerSettingsManager; without an opening snapshot, mode lookups read it. - provider["initialModeConfigIds"] = Promise.resolve(undefined) + // Tests provide explicit opening snapshots when they need saved mode profiles. + provider["initialModeConfigIds"] = Promise.resolve({}) // Mock providerSettingsManager ;(provider as any).providerSettingsManager = { @@ -977,6 +977,7 @@ describe("ClineProvider - API Handler Rebuild Guard", () => { }, }) await provider.addClineToStack(mockTask) + provider["initialModeConfigIds"] = Promise.resolve({ ask: "ask-id" }) provider["providerSettingsManager"].getModeConfigId = vi.fn().mockResolvedValue("ask-id") provider["providerSettingsManager"].listConfig = vi .fn() diff --git a/src/core/webview/__tests__/ClineProvider.lockApiConfig.spec.ts b/src/core/webview/__tests__/ClineProvider.lockApiConfig.spec.ts index 6e22e35902..7c85e90e76 100644 --- a/src/core/webview/__tests__/ClineProvider.lockApiConfig.spec.ts +++ b/src/core/webview/__tests__/ClineProvider.lockApiConfig.spec.ts @@ -331,8 +331,8 @@ describe("ClineProvider - Lock API Config Across Modes", () => { new ContextProxy(mockContext), new WebviewFocusTracker(), ) - // These tests stub providerSettingsManager; without an opening snapshot, mode lookups read it. - provider["initialModeConfigIds"] = Promise.resolve(undefined) + // Tests provide explicit opening snapshots when they need saved mode profiles. + provider["initialModeConfigIds"] = Promise.resolve({}) // Mock getMcpHub method provider.getMcpHub = vi.fn().mockReturnValue({ @@ -392,9 +392,10 @@ describe("ClineProvider - Lock API Config Across Modes", () => { apiProvider: providerIdentifiers.anthropic, }) + provider["initialModeConfigIds"] = Promise.resolve({ architect: "architect-profile-id" }) await provider.handleModeSwitch("architect") - expect(getModeConfigIdSpy).toHaveBeenCalledWith("architect") + expect(getModeConfigIdSpy).not.toHaveBeenCalled() expect(activateProfileSpy).toHaveBeenCalledWith({ name: "architect-profile" }) }) }) diff --git a/src/core/webview/__tests__/ClineProvider.spec.ts b/src/core/webview/__tests__/ClineProvider.spec.ts index a828e64497..a11048d7fb 100644 --- a/src/core/webview/__tests__/ClineProvider.spec.ts +++ b/src/core/webview/__tests__/ClineProvider.spec.ts @@ -558,9 +558,8 @@ describe("ClineProvider", () => { new ContextProxy(mockContext), new WebviewFocusTracker(), ) - // Most tests stub providerSettingsManager and expect it to be consulted for mode profiles, - // so start without the snapshot the real manager would take of the seeded mode map. - provider["initialModeConfigIds"] = Promise.resolve(undefined) + // Tests provide explicit opening snapshots when they need saved mode profiles. + provider["initialModeConfigIds"] = Promise.resolve({}) defaultTaskOptions = { provider, @@ -4464,6 +4463,7 @@ describe("ClineProvider", () => { apiProvider: providerIdentifiers.anthropic, } + provider["initialModeConfigIds"] = Promise.resolve({ architect: "test-id" }) ;(provider as any).providerSettingsManager = { getModeConfigId: vi.fn().mockResolvedValue("test-id"), listConfig: vi.fn().mockResolvedValue([profile]), @@ -4476,7 +4476,7 @@ describe("ClineProvider", () => { await messageHandler({ type: "mode", text: "architect" }) // Should load the saved config for architect mode - expect(provider.providerSettingsManager.getModeConfigId).toHaveBeenCalledWith("architect") + expect(provider.providerSettingsManager.getModeConfigId).not.toHaveBeenCalled() expect(provider.providerSettingsManager.activateProfile).toHaveBeenCalledWith({ name: "test-config" }) expect(mockContext.globalState.update).toHaveBeenCalledWith("currentApiConfigName", "test-config") }) @@ -4536,13 +4536,18 @@ describe("ClineProvider", () => { }, ) - it("falls back to the shared value when the snapshot cannot be read", async () => { + it("keeps the current profile when the snapshot cannot be read", async () => { vi.spyOn(provider.providerSettingsManager, "getModeConfigIds").mockRejectedValue(new Error("unreadable")) vi.spyOn(provider.providerSettingsManager, "getModeConfigId").mockResolvedValue("shared-id") provider["captureInitialModeConfigIds"]() - await expect(provider["getModeConfigId"]("architect")).resolves.toBe("shared-id") + await expect(provider["getModeConfigId"]("architect")).resolves.toBeUndefined() + expect(provider.providerSettingsManager.getModeConfigId).not.toHaveBeenCalled() + existingProfiles("chosen-id") + vi.spyOn(provider.providerSettingsManager, "setModeConfig").mockResolvedValue(undefined) + await provider.setModeConfig("architect", "chosen-id") + await expect(provider["getModeConfigId"]("architect")).resolves.toBe("chosen-id") }) it("drops a local choice whose profile was removed and falls back to the shared mapping", async () => { @@ -4628,6 +4633,31 @@ describe("ClineProvider", () => { await expect(provider["getModeConfigId"]("architect")).resolves.toBeUndefined() }) + it.each(["first-id", "second-id"])( + "preserves a successful overlapping write of %s after the preceding write fails", + async (nextId) => { + existingProfiles("first-id", "second-id") + const sharedWrite = vi.spyOn(provider.providerSettingsManager, "setModeConfig").mockResolvedValue() + await provider.setModeConfig("code", "first-id") + let rejectWrite = (_error: Error) => {} + sharedWrite.mockImplementationOnce( + () => + new Promise((_resolve, reject) => { + rejectWrite = reject + }), + ) + const failed = provider.setModeConfig("code", "second-id") + const failure = expect(failed).rejects.toThrow("write failed") + const succeeded = provider.setModeConfig("code", nextId) + expect(sharedWrite).toHaveBeenCalledTimes(2) + rejectWrite(new Error("write failed")) + await failure + await succeeded + expect(sharedWrite).toHaveBeenLastCalledWith("code", nextId) + await expect(provider["getModeConfigId"]("code")).resolves.toBe(nextId) + }, + ) + it("drops local choices and re-reads the mapping when state is reset", async () => { const { t } = await import("../../../i18n") vi.mocked(vscode.window.showInformationMessage).mockResolvedValueOnce(t("common:answers.yes") as never) @@ -5234,6 +5264,7 @@ describe("ClineProvider", () => { apiProvider: providerIdentifiers.anthropic, } + provider["initialModeConfigIds"] = Promise.resolve({ architect: "saved-config-id" }) ;(provider as any).providerSettingsManager = { getModeConfigId: vi.fn().mockResolvedValue("saved-config-id"), listConfig: vi.fn().mockResolvedValue([profile]), @@ -5249,7 +5280,7 @@ describe("ClineProvider", () => { expect(mockContext.globalState.update).toHaveBeenCalledWith("mode", "architect") // Verify saved config was loaded - expect(provider.providerSettingsManager.getModeConfigId).toHaveBeenCalledWith("architect") + expect(provider.providerSettingsManager.getModeConfigId).not.toHaveBeenCalled() expect(provider.providerSettingsManager.activateProfile).toHaveBeenCalledWith({ name: "saved-config" }) expect(mockContext.globalState.update).toHaveBeenCalledWith("currentApiConfigName", "saved-config") @@ -5384,6 +5415,7 @@ describe("ClineProvider", () => { }) // Mock provider settings manager + provider["initialModeConfigIds"] = Promise.resolve({ "custom-mode": "config-id" }) ;(provider as any).providerSettingsManager = { getModeConfigId: vi.fn().mockResolvedValue("config-id"), listConfig: vi @@ -5523,6 +5555,7 @@ describe("ClineProvider", () => { }) // Mock provider settings manager to throw error + provider["initialModeConfigIds"] = Promise.resolve({ code: "config-id" }) ;(provider as any).providerSettingsManager = { getModeConfigId: vi.fn().mockResolvedValue("config-id"), listConfig: vi diff --git a/src/extension/__tests__/api-configuration.spec.ts b/src/extension/__tests__/api-configuration.spec.ts index 3b19fc0f2c..31b0be733c 100644 --- a/src/extension/__tests__/api-configuration.spec.ts +++ b/src/extension/__tests__/api-configuration.spec.ts @@ -28,8 +28,10 @@ describe("API - configuration", () => { ]), }, localModeConfigIds: new Map(), + modeConfigWrites: new Map>(), initialModeConfigIds: Promise.resolve({}), setModeConfig: ClineProvider.prototype.setModeConfig, + writeModeConfig: ClineProvider.prototype["writeModeConfig"], getModeConfigId: ClineProvider.prototype["getModeConfigId"], postStateToWebview, // Provides the configuration methods and event registration used by API. From e4d28bb6db329ba5a1def308485c59ad1def4869 Mon Sep 17 00:00:00 2001 From: Elliott de Launay Date: Tue, 10 Nov 2026 01:41:52 +0000 Subject: [PATCH 09/30] fix: preserve mode profile ordering during imports and stop cancelled lookups --- src/core/config/ProviderSettingsManager.ts | 11 +- .../__tests__/ProviderSettingsManager.spec.ts | 30 +++ .../config/__tests__/importExport.spec.ts | 4 +- src/core/config/importExport.ts | 9 +- src/core/webview/ClineProvider.ts | 19 +- .../webview/__tests__/ClineProvider.spec.ts | 171 +++++++++++++++++- .../ClineProvider.sticky-profile.spec.ts | 6 +- .../__tests__/api-configuration.spec.ts | 4 +- 8 files changed, 231 insertions(+), 23 deletions(-) diff --git a/src/core/config/ProviderSettingsManager.ts b/src/core/config/ProviderSettingsManager.ts index a355b2ff01..058ed63483 100644 --- a/src/core/config/ProviderSettingsManager.ts +++ b/src/core/config/ProviderSettingsManager.ts @@ -543,7 +543,7 @@ export class ProviderSettingsManager { /** * Set the API config for a specific mode. */ - public async setModeConfig(mode: Mode, configId: string) { + public async setModeConfig(mode: Mode, configId: string, onPersisted?: () => void) { try { return await this.lock(async () => { const providerProfiles = await this.load() @@ -554,6 +554,7 @@ export class ProviderSettingsManager { // Assign the chosen config ID to this mode providerProfiles.modeApiConfigs[mode] = configId await this.store(providerProfiles) + onPersisted?.() }) } catch (error) { throw new Error(`Failed to set mode config: ${error}`) @@ -651,9 +652,13 @@ export class ProviderSettingsManager { } } - public async import(providerProfiles: ProviderProfiles) { + public async import(providerProfiles: ProviderProfiles, onPersisted?: () => void) { try { - return await this.lock(() => this.store(providerProfiles)) + return await this.lock(async () => { + await this.store(providerProfiles) + // Publish local choices before a later writer can acquire the storage lock. + onPersisted?.() + }) } catch (error) { throw new Error(`Failed to import provider profiles: ${error}`) } diff --git a/src/core/config/__tests__/ProviderSettingsManager.spec.ts b/src/core/config/__tests__/ProviderSettingsManager.spec.ts index c77464f9f2..66f42b9b40 100644 --- a/src/core/config/__tests__/ProviderSettingsManager.spec.ts +++ b/src/core/config/__tests__/ProviderSettingsManager.spec.ts @@ -89,6 +89,36 @@ describe("ProviderSettingsManager", () => { providerSettingsManager = new ProviderSettingsManager(mockContext) }) + it.each([ + { operation: "import", fails: false }, + { operation: "import", fails: true }, + { operation: "mode write", fails: false }, + { operation: "mode write", fails: true }, + ])("publishes $operation choices only after persistence (failure: $fails)", async ({ operation, fails }) => { + let release = () => {} + const pending = new Promise((resolve) => { + release = resolve + }) + mockSecrets.store.mockImplementationOnce(async () => { + await pending + if (fails) throw new Error("write failed") + }) + const published = vi.fn() + const write = + operation === "import" + ? providerSettingsManager.import( + { currentApiConfigName: "default", apiConfigs: {}, modeApiConfigs: { code: "imported-id" } }, + published, + ) + : providerSettingsManager.setModeConfig("code", "chosen-id", published) + await vi.waitFor(() => expect(mockSecrets.store).toHaveBeenCalledOnce()) + expect(published).not.toHaveBeenCalled() + const result = fails ? expect(write).rejects.toThrow("write failed") : expect(write).resolves.toBeUndefined() + release() + await result + expect(published).toHaveBeenCalledTimes(fails ? 0 : 1) + }) + describe("initialize", () => { it("should not write to storage when secrets.get returns null", async () => { // Mock readConfig to return null diff --git a/src/core/config/__tests__/importExport.spec.ts b/src/core/config/__tests__/importExport.spec.ts index de654db60c..2e840b7ab2 100644 --- a/src/core/config/__tests__/importExport.spec.ts +++ b/src/core/config/__tests__/importExport.spec.ts @@ -187,7 +187,9 @@ describe("importExport", () => { beforeEach(() => { ;(fs.readFile as Mock).mockResolvedValue(validFileContent) mockProviderSettingsManager.export.mockResolvedValue(previousProviderProfiles) - mockProviderSettingsManager.import.mockResolvedValue(undefined) + mockProviderSettingsManager.import.mockImplementation(async (_profiles, onPersisted) => { + onPersisted?.() + }) mockProviderSettingsManager.listConfig.mockResolvedValue(profileMetadata) mockContextProxy.setValues.mockResolvedValue(undefined) mockContextProxy.setValue.mockResolvedValue(undefined) diff --git a/src/core/config/importExport.ts b/src/core/config/importExport.ts index df9281804d..0dca4c1a58 100644 --- a/src/core/config/importExport.ts +++ b/src/core/config/importExport.ts @@ -229,8 +229,13 @@ export async function importSettingsFromPath( // OpenAI Compatible settings are now correctly stored in codebaseIndexConfig // They will be imported automatically with the config - no special handling needed - await providerSettingsManager.import(providerProfiles) - onModeConfigIdsImported?.(rawProviderProfiles.modeApiConfigs ?? {}) + if (onModeConfigIdsImported) { + await providerSettingsManager.import(providerProfiles, () => + onModeConfigIdsImported(rawProviderProfiles.modeApiConfigs ?? {}), + ) + } else { + await providerSettingsManager.import(providerProfiles) + } await contextProxy.setValues(sanitizedGlobalSettings) // Set the current provider. diff --git a/src/core/webview/ClineProvider.ts b/src/core/webview/ClineProvider.ts index 3d46f26e02..5b1c3a6e5a 100644 --- a/src/core/webview/ClineProvider.ts +++ b/src/core/webview/ClineProvider.ts @@ -2115,7 +2115,8 @@ export class ClineProvider if (signal?.aborted) return // Load the saved API config for the new mode if it exists. - const savedConfigId = await this.getModeConfigId(newMode) + const savedConfigId = await this.getModeConfigId(newMode, signal) + if (signal?.aborted) return const listApiConfig = await this.providerSettingsManager.listConfig() if (signal?.aborted) return @@ -2183,23 +2184,26 @@ export class ClineProvider * id whose profile no longer exists (e.g. after a reset) is dropped in favour of the shared map, * while an unreadable opening snapshot keeps this window’s current profile. */ - private async getModeConfigId(mode: Mode): Promise { + private async getModeConfigId(mode: Mode, signal?: AbortSignal): Promise { + if (signal?.aborted) return undefined const localId = this.localModeConfigIds.get(mode) const initialIds = localId === undefined ? await this.initialModeConfigIds : undefined - if (this.localModeConfigIds.get(mode) !== localId) return this.getModeConfigId(mode) + if (signal?.aborted) return undefined + if (this.localModeConfigIds.get(mode) !== localId) return this.getModeConfigId(mode, signal) const cachedId = localId ?? initialIds?.[mode] if (cachedId === undefined) return undefined const profiles = await this.providerSettingsManager.listConfig() + if (signal?.aborted) return undefined // A profile selection may have changed while either asynchronous read was pending. - if (this.localModeConfigIds.get(mode) !== localId) return this.getModeConfigId(mode) + if (this.localModeConfigIds.get(mode) !== localId) return this.getModeConfigId(mode, signal) if (profiles.some(({ id }) => id === cachedId)) return cachedId if (localId !== undefined) this.localModeConfigIds.delete(mode) return this.providerSettingsManager.getModeConfigId(mode) } - /** Adopt only mappings explicitly written by an import in this window. */ + /** Adopt imported mappings from the manager's persistence callback, while its storage lock is held. */ public adoptModeConfigIds(ids: Record): void { for (const [mode, id] of Object.entries(ids)) { this.localModeConfigIds.set(mode, id) @@ -2225,7 +2229,10 @@ export class ClineProvider const previousId = this.localModeConfigIds.get(mode) this.localModeConfigIds.set(mode, id) try { - await this.providerSettingsManager.setModeConfig(mode, id) + await this.providerSettingsManager.setModeConfig(mode, id, () => { + // An import may have adopted another choice while this write waited for the storage lock. + this.localModeConfigIds.set(mode, id) + }) } catch (error) { // Keep this window consistent with the shared map the failed write left unchanged. if (this.localModeConfigIds.get(mode) === id) { diff --git a/src/core/webview/__tests__/ClineProvider.spec.ts b/src/core/webview/__tests__/ClineProvider.spec.ts index a11048d7fb..0f7e53db4c 100644 --- a/src/core/webview/__tests__/ClineProvider.spec.ts +++ b/src/core/webview/__tests__/ClineProvider.spec.ts @@ -28,6 +28,7 @@ import { TelemetryService } from "@roo-code/telemetry" import { defaultModeSlug } from "../../../shared/modes" import { experimentDefault } from "../../../shared/experiments" import { setTtsEnabled } from "../../../utils/tts" +import { ProviderSettingsManager } from "../../config/ProviderSettingsManager" import { ContextProxy } from "../../config/ContextProxy" import { WorkspaceIndexingEnablementManager } from "../../../services/code-index/workspace-indexing-enablement-manager" import { Task, TaskOptions } from "../../task/Task" @@ -38,7 +39,12 @@ import { webviewMessageHandler } from "../webviewMessageHandler" import { Terminal } from "../../../integrations/terminal/Terminal" import { MessageManager } from "../../message-manager" import { forceFullModelDetailsLoad, hasLoadedFullDetails } from "../../../api/providers/fetchers/lmstudio" -import { makeCompositeDisposable, makeEventEmitter } from "../../../test-utils/vscode" +import { + makeCompositeDisposable, + makeEventEmitter, + makeUri, + makeWorkspaceConfiguration, +} from "../../../test-utils/vscode" import { WebviewFocusTracker } from "../WebviewFocusTracker" import { resolveChatProvider } from "../../../activate/resolveChatProvider" @@ -4487,6 +4493,135 @@ describe("ClineProvider", () => { .spyOn(provider.providerSettingsManager, "listConfig") .mockResolvedValue(ids.map((id) => ({ name: `${id}-name`, id }))) + it.each([false, true])("captures opening choices in the constructor (read failure: %s)", async (fails) => { + const snapshot = vi.spyOn(ProviderSettingsManager.prototype, "getModeConfigIds") + if (fails) snapshot.mockRejectedValueOnce(new Error("unreadable")) + else snapshot.mockResolvedValueOnce({ code: "opened-id" }) + const opened = new ClineProvider( + mockContext, + mockOutputChannel, + "sidebar", + new ContextProxy(mockContext), + new WebviewFocusTracker(), + ) + try { + expect(snapshot).toHaveBeenCalledOnce() + vi.spyOn(opened.providerSettingsManager, "listConfig").mockResolvedValue([ + { name: "opened", id: "opened-id" }, + ]) + const sharedLookup = vi + .spyOn(opened.providerSettingsManager, "getModeConfigId") + .mockResolvedValue("other-window-id") + snapshot.mockResolvedValue({ code: "other-window-id" }) + await expect(opened["getModeConfigId"]("code")).resolves.toBe(fails ? undefined : "opened-id") + expect(sharedLookup).not.toHaveBeenCalled() + } finally { + await opened.dispose() + snapshot.mockRestore() + } + }) + + it.each(["snapshot", "profiles"])("stops a cancelled mode switch during %s lookup", async (stage) => { + let release = () => {} + const pending = new Promise((resolve) => { + release = resolve + }) + provider["initialModeConfigIds"] = + stage === "snapshot" + ? pending.then(() => ({ code: "opened-id" })) + : Promise.resolve({ code: "opened-id" }) + const list = vi.spyOn(provider.providerSettingsManager, "listConfig").mockImplementation(async () => { + if (stage === "profiles") await pending + return [{ name: "opened", id: "opened-id" }] + }) + const lookup = vi.fn(provider["getModeConfigId"].bind(provider)) + provider["getModeConfigId"] = lookup + const controller = new AbortController() + const switched = provider["handleModeSwitchUnlocked"]("code", null, controller.signal) + await vi.waitFor(() => expect(lookup).toHaveBeenCalledOnce()) + if (stage === "profiles") await vi.waitFor(() => expect(list).toHaveBeenCalledOnce()) + controller.abort() + release() + await switched + expect(list).toHaveBeenCalledTimes(stage === "snapshot" ? 0 : 1) + expect(provider["localModeConfigIds"].has("code")).toBe(false) + }) + + it.each(["manual", "automatic"])("adopts imported choices through the %s import entry point", async (entry) => { + const filePath = "/settings.json" + const fsPromises = (await import("fs/promises")).default + const originalReadFile = vi.mocked(fsPromises.readFile).getMockImplementation()! + vi.mocked(fsPromises.readFile).mockResolvedValue( + JSON.stringify({ + providerProfiles: { + currentApiConfigName: "imported", + apiConfigs: { imported: { id: "imported-id", apiProvider: providerIdentifiers.anthropic } }, + modeApiConfigs: { code: "imported-id" }, + }, + globalSettings: {}, + }), + ) + vi.spyOn(provider, "postStateToWebview").mockResolvedValue(undefined) + const options = { + providerSettingsManager: provider.providerSettingsManager, + contextProxy: provider.contextProxy, + customModesManager: provider.customModesManager, + provider, + } + if (entry === "manual") { + vi.mocked(vscode.window.showOpenDialog).mockResolvedValueOnce([makeUri(filePath)]) + const { importSettingsWithFeedback } = await import("../../config/importExport") + await importSettingsWithFeedback(options) + } else { + const fsUtils = await import("../../../utils/fs") + const exists = vi.spyOn(fsUtils, "fileExistsAtPath").mockResolvedValue(true) + const originalGetConfiguration = vi.mocked(vscode.workspace.getConfiguration).getMockImplementation()! + vi.mocked(vscode.workspace.getConfiguration).mockReturnValue( + makeWorkspaceConfiguration({ autoImportSettingsPath: filePath }), + ) + const { autoImportSettings } = await import("../../../utils/autoImportSettings") + await autoImportSettings(mockOutputChannel, { + ...options, + onModeConfigIdsImported: (ids) => provider.adoptModeConfigIds(ids), + }) + expect(mockOutputChannel.appendLine).toHaveBeenCalledWith( + expect.stringContaining("Successfully imported settings"), + ) + exists.mockRestore() + vi.mocked(vscode.workspace.getConfiguration).mockImplementation(originalGetConfiguration) + } + await expect(provider["getModeConfigId"]("code")).resolves.toBe("imported-id") + await expect(provider.providerSettingsManager.getModeConfigId("code")).resolves.toBe("imported-id") + vi.mocked(fsPromises.readFile).mockImplementation(originalReadFile) + }) + + it.each(["import-first", "choice-first"])("keeps local choices in persisted order (%s)", async (order) => { + const manager = provider.providerSettingsManager + const profiles = { + currentApiConfigName: "imported", + apiConfigs: { imported: { id: "imported-id" }, chosen: { id: "chosen-id" } }, + modeApiConfigs: { code: "imported-id" }, + } + let release = () => {} + const pending = new Promise((resolve) => { + release = resolve + }) + const originalStore = vi.mocked(mockContext.secrets.store).getMockImplementation()! + vi.spyOn(mockContext.secrets, "store").mockImplementationOnce(async (key, value) => { + await pending + await originalStore(key, value) + }) + const imported = () => manager.import(profiles, () => provider.adoptModeConfigIds(profiles.modeApiConfigs)) + const chosen = () => provider.setModeConfig("code", "chosen-id") + const first = order === "import-first" ? imported() : chosen() + const second = order === "import-first" ? chosen() : imported() + release() + await Promise.all([first, second]) + const expected = order === "import-first" ? "chosen-id" : "imported-id" + await expect(manager.getModeConfigId("code")).resolves.toBe(expected) + await expect(provider["getModeConfigId"]("code")).resolves.toBe(expected) + }) + it("prefers this window's mode profile over one another window saved in shared storage", async () => { const manager = provider.providerSettingsManager existingProfiles("this-window-id", "other-window-id") @@ -4495,7 +4630,7 @@ describe("ClineProvider", () => { await provider["setModeConfig"]("code", "this-window-id") - expect(manager.setModeConfig).toHaveBeenCalledWith("code", "this-window-id") + expect(manager.setModeConfig).toHaveBeenCalledWith("code", "this-window-id", expect.any(Function)) await expect(provider["getModeConfigId"]("code")).resolves.toBe("this-window-id") }) @@ -4653,7 +4788,7 @@ describe("ClineProvider", () => { rejectWrite(new Error("write failed")) await failure await succeeded - expect(sharedWrite).toHaveBeenLastCalledWith("code", nextId) + expect(sharedWrite).toHaveBeenLastCalledWith("code", nextId, expect.any(Function)) await expect(provider["getModeConfigId"]("code")).resolves.toBe(nextId) }, ) @@ -4698,7 +4833,11 @@ describe("ClineProvider", () => { await messageHandler({ type: "mode", text: "architect" }) // Should save current config as default for architect mode - expect(provider.providerSettingsManager.setModeConfig).toHaveBeenCalledWith("architect", "current-id") + expect(provider.providerSettingsManager.setModeConfig).toHaveBeenCalledWith( + "architect", + "current-id", + expect.any(Function), + ) }) it("saves config as default for current mode when loading config", async () => { @@ -4725,7 +4864,11 @@ describe("ClineProvider", () => { await messageHandler({ type: "loadApiConfiguration", text: "new-config" }) // Should save new config as default for architect mode - expect(provider.providerSettingsManager.setModeConfig).toHaveBeenCalledWith("architect", "new-id") + expect(provider.providerSettingsManager.setModeConfig).toHaveBeenCalledWith( + "architect", + "new-id", + expect.any(Function), + ) }) it("load API configuration by ID works and updates mode config", async () => { @@ -4752,7 +4895,11 @@ describe("ClineProvider", () => { await messageHandler({ type: "loadApiConfigurationById", text: "config-id-123" }) // Should save new config as default for architect mode - expect(provider.providerSettingsManager.setModeConfig).toHaveBeenCalledWith("architect", "config-id-123") + expect(provider.providerSettingsManager.setModeConfig).toHaveBeenCalledWith( + "architect", + "config-id-123", + expect.any(Function), + ) // Ensure the `activateProfile` method was called with the correct ID expect(provider.providerSettingsManager.activateProfile).toHaveBeenCalledWith({ id: "config-id-123" }) @@ -4932,7 +5079,11 @@ describe("ClineProvider", () => { }) // Should save config as default for current mode - expect(provider.providerSettingsManager.setModeConfig).toHaveBeenCalledWith("code", "test-id") + expect(provider.providerSettingsManager.setModeConfig).toHaveBeenCalledWith( + "code", + "test-id", + expect.any(Function), + ) }) test("file content includes line numbers", async () => { @@ -5314,7 +5465,11 @@ describe("ClineProvider", () => { expect(mockContext.globalState.update).toHaveBeenCalledWith("mode", "architect") // Verify current config was saved as default for new mode - expect(provider.providerSettingsManager.setModeConfig).toHaveBeenCalledWith("architect", "current-id") + expect(provider.providerSettingsManager.setModeConfig).toHaveBeenCalledWith( + "architect", + "current-id", + expect.any(Function), + ) // Verify state was posted to webview expect(mockPostMessage).toHaveBeenCalledWith(expect.objectContaining({ type: "state" })) diff --git a/src/core/webview/__tests__/ClineProvider.sticky-profile.spec.ts b/src/core/webview/__tests__/ClineProvider.sticky-profile.spec.ts index 11a3fafeaf..e508fbd2de 100644 --- a/src/core/webview/__tests__/ClineProvider.sticky-profile.spec.ts +++ b/src/core/webview/__tests__/ClineProvider.sticky-profile.spec.ts @@ -456,7 +456,11 @@ describe("ClineProvider - Sticky Provider Profile", () => { ) if (persistModeConfig) { - expect(setModeConfigSpy).toHaveBeenCalledExactlyOnceWith("architect", "new-profile-id") + expect(setModeConfigSpy).toHaveBeenCalledExactlyOnceWith( + "architect", + "new-profile-id", + expect.any(Function), + ) } else { expect(setModeConfigSpy).not.toHaveBeenCalled() } diff --git a/src/extension/__tests__/api-configuration.spec.ts b/src/extension/__tests__/api-configuration.spec.ts index 31b0be733c..b093eb2be2 100644 --- a/src/extension/__tests__/api-configuration.spec.ts +++ b/src/extension/__tests__/api-configuration.spec.ts @@ -52,8 +52,8 @@ describe("API - configuration", () => { }), ) expect(setModeConfig).toHaveBeenCalledTimes(2) - expect(setModeConfig).toHaveBeenCalledWith("code", "code-config") - expect(setModeConfig).toHaveBeenCalledWith("new-custom-mode", "architect-config") + expect(setModeConfig).toHaveBeenCalledWith("code", "code-config", expect.any(Function)) + expect(setModeConfig).toHaveBeenCalledWith("new-custom-mode", "architect-config", expect.any(Function)) await expect(provider["getModeConfigId"]("code")).resolves.toBe("code-config") await expect(provider["getModeConfigId"]("new-custom-mode")).resolves.toBe("architect-config") expect(postStateToWebview).toHaveBeenCalledOnce() From 9ca521f65504eff0f2931cff59277a07c700ef13 Mon Sep 17 00:00:00 2001 From: Elliott de Launay Date: Tue, 10 Nov 2026 23:33:35 +0000 Subject: [PATCH 10/30] fix: preserve imported mode profiles when overlapping writes fail --- src/__tests__/extension.spec.ts | 16 +++ src/core/webview/ClineProvider.ts | 11 +- .../webview/__tests__/ClineProvider.spec.ts | 134 ++++++++++++------ .../ClineProvider.sticky-mode.spec.ts | 8 +- .../__tests__/api-configuration.spec.ts | 1 + 5 files changed, 120 insertions(+), 50 deletions(-) diff --git a/src/__tests__/extension.spec.ts b/src/__tests__/extension.spec.ts index abcd3c28a0..d4252dc08f 100644 --- a/src/__tests__/extension.spec.ts +++ b/src/__tests__/extension.spec.ts @@ -202,6 +202,7 @@ vi.mock("../core/webview/ClineProvider", async () => { contextProxy: { getGlobalState: vi.fn() }, customModesManager: {}, upsertProviderProfile: vi.fn().mockResolvedValue(undefined), + adoptModeConfigIds: vi.fn(), } return { ClineProvider: Object.assign( @@ -245,6 +246,21 @@ describe("extension.ts", () => { settingsUpdatedHandler = undefined }) + test("adopts mode profile mappings from the activation auto-import callback", async () => { + const { activate } = await import("../extension") + const { autoImportSettings } = await import("../utils/autoImportSettings") + const { ClineProvider } = await import("../core/webview/ClineProvider") + const ids = { code: "imported-id" } + vi.mocked(autoImportSettings).mockImplementationOnce(async (_output, options) => { + expect(options.onModeConfigIdsImported).toBeTypeOf("function") + options.onModeConfigIdsImported?.(ids) + }) + + await activate(mockContext) + + expect(ClineProvider.getVisibleInstance()!.adoptModeConfigIds).toHaveBeenCalledExactlyOnceWith(ids) + }) + test("shares the extension-owned focus tracker with the sidebar and code actions and disposes its listeners", async () => { vi.resetModules() const { WebviewFocusTracker } = await import("../core/webview/WebviewFocusTracker") diff --git a/src/core/webview/ClineProvider.ts b/src/core/webview/ClineProvider.ts index 5b1c3a6e5a..e7a8894d75 100644 --- a/src/core/webview/ClineProvider.ts +++ b/src/core/webview/ClineProvider.ts @@ -426,6 +426,7 @@ export class ClineProvider * alone lets another window's profile selection leak into this window's tasks. */ private readonly localModeConfigIds = new Map() + private readonly modeConfigWriteOwners = new Map() /** * The shared mode map as it was when this window opened. Modes this window has not changed @@ -2207,6 +2208,7 @@ export class ClineProvider public adoptModeConfigIds(ids: Record): void { for (const [mode, id] of Object.entries(ids)) { this.localModeConfigIds.set(mode, id) + this.modeConfigWriteOwners.delete(mode) } } @@ -2227,6 +2229,8 @@ export class ClineProvider private async writeModeConfig(mode: Mode, id: string): Promise { const previousId = this.localModeConfigIds.get(mode) + const owner = Symbol() + this.modeConfigWriteOwners.set(mode, owner) this.localModeConfigIds.set(mode, id) try { await this.providerSettingsManager.setModeConfig(mode, id, () => { @@ -2234,12 +2238,14 @@ export class ClineProvider this.localModeConfigIds.set(mode, id) }) } catch (error) { - // Keep this window consistent with the shared map the failed write left unchanged. - if (this.localModeConfigIds.get(mode) === id) { + // Only roll back our optimistic update; an import may have adopted even the same ID. + if (this.modeConfigWriteOwners.get(mode) === owner) { if (previousId === undefined) this.localModeConfigIds.delete(mode) else this.localModeConfigIds.set(mode, previousId) } throw error + } finally { + if (this.modeConfigWriteOwners.get(mode) === owner) this.modeConfigWriteOwners.delete(mode) } } @@ -3833,6 +3839,7 @@ export class ClineProvider await this.providerSettingsManager.resetAllConfigs() // Cached choices point at profiles that no longer exist; re-read the reset mapping. this.localModeConfigIds.clear() + this.modeConfigWriteOwners.clear() this.captureInitialModeConfigIds() await this.customModesManager.resetCustomModes() await this.removeClineFromStack() diff --git a/src/core/webview/__tests__/ClineProvider.spec.ts b/src/core/webview/__tests__/ClineProvider.spec.ts index 0f7e53db4c..3c8a671dd5 100644 --- a/src/core/webview/__tests__/ClineProvider.spec.ts +++ b/src/core/webview/__tests__/ClineProvider.spec.ts @@ -4547,53 +4547,62 @@ describe("ClineProvider", () => { expect(provider["localModeConfigIds"].has("code")).toBe(false) }) - it.each(["manual", "automatic"])("adopts imported choices through the %s import entry point", async (entry) => { - const filePath = "/settings.json" - const fsPromises = (await import("fs/promises")).default - const originalReadFile = vi.mocked(fsPromises.readFile).getMockImplementation()! - vi.mocked(fsPromises.readFile).mockResolvedValue( - JSON.stringify({ - providerProfiles: { - currentApiConfigName: "imported", - apiConfigs: { imported: { id: "imported-id", apiProvider: providerIdentifiers.anthropic } }, - modeApiConfigs: { code: "imported-id" }, - }, - globalSettings: {}, - }), - ) - vi.spyOn(provider, "postStateToWebview").mockResolvedValue(undefined) - const options = { - providerSettingsManager: provider.providerSettingsManager, - contextProxy: provider.contextProxy, - customModesManager: provider.customModesManager, - provider, - } - if (entry === "manual") { - vi.mocked(vscode.window.showOpenDialog).mockResolvedValueOnce([makeUri(filePath)]) - const { importSettingsWithFeedback } = await import("../../config/importExport") - await importSettingsWithFeedback(options) - } else { - const fsUtils = await import("../../../utils/fs") - const exists = vi.spyOn(fsUtils, "fileExistsAtPath").mockResolvedValue(true) - const originalGetConfiguration = vi.mocked(vscode.workspace.getConfiguration).getMockImplementation()! - vi.mocked(vscode.workspace.getConfiguration).mockReturnValue( - makeWorkspaceConfiguration({ autoImportSettingsPath: filePath }), - ) - const { autoImportSettings } = await import("../../../utils/autoImportSettings") - await autoImportSettings(mockOutputChannel, { - ...options, - onModeConfigIdsImported: (ids) => provider.adoptModeConfigIds(ids), - }) - expect(mockOutputChannel.appendLine).toHaveBeenCalledWith( - expect.stringContaining("Successfully imported settings"), + it.each(["manual", "automatic", "explicit-path"])( + "adopts imported choices through the %s import entry point", + async (entry) => { + const filePath = "/settings.json" + const fsPromises = (await import("fs/promises")).default + const originalReadFile = vi.mocked(fsPromises.readFile).getMockImplementation()! + vi.mocked(fsPromises.readFile).mockResolvedValue( + JSON.stringify({ + providerProfiles: { + currentApiConfigName: "imported", + apiConfigs: { imported: { id: "imported-id", apiProvider: providerIdentifiers.anthropic } }, + modeApiConfigs: { code: "imported-id" }, + }, + globalSettings: {}, + }), ) - exists.mockRestore() - vi.mocked(vscode.workspace.getConfiguration).mockImplementation(originalGetConfiguration) - } - await expect(provider["getModeConfigId"]("code")).resolves.toBe("imported-id") - await expect(provider.providerSettingsManager.getModeConfigId("code")).resolves.toBe("imported-id") - vi.mocked(fsPromises.readFile).mockImplementation(originalReadFile) - }) + vi.spyOn(provider, "postStateToWebview").mockResolvedValue(undefined) + const options = { + providerSettingsManager: provider.providerSettingsManager, + contextProxy: provider.contextProxy, + customModesManager: provider.customModesManager, + provider, + } + if (entry === "explicit-path") { + vi.spyOn(fsPromises, "access").mockResolvedValueOnce(undefined) + const { importSettingsWithFeedback } = await import("../../config/importExport") + await importSettingsWithFeedback(options, filePath) + } else if (entry === "manual") { + vi.mocked(vscode.window.showOpenDialog).mockResolvedValueOnce([makeUri(filePath)]) + const { importSettingsWithFeedback } = await import("../../config/importExport") + await importSettingsWithFeedback(options) + } else { + const fsUtils = await import("../../../utils/fs") + const exists = vi.spyOn(fsUtils, "fileExistsAtPath").mockResolvedValue(true) + const originalGetConfiguration = vi + .mocked(vscode.workspace.getConfiguration) + .getMockImplementation()! + vi.mocked(vscode.workspace.getConfiguration).mockReturnValue( + makeWorkspaceConfiguration({ autoImportSettingsPath: filePath }), + ) + const { autoImportSettings } = await import("../../../utils/autoImportSettings") + await autoImportSettings(mockOutputChannel, { + ...options, + onModeConfigIdsImported: (ids) => provider.adoptModeConfigIds(ids), + }) + expect(mockOutputChannel.appendLine).toHaveBeenCalledWith( + expect.stringContaining("Successfully imported settings"), + ) + exists.mockRestore() + vi.mocked(vscode.workspace.getConfiguration).mockImplementation(originalGetConfiguration) + } + await expect(provider["getModeConfigId"]("code")).resolves.toBe("imported-id") + await expect(provider.providerSettingsManager.getModeConfigId("code")).resolves.toBe("imported-id") + vi.mocked(fsPromises.readFile).mockImplementation(originalReadFile) + }, + ) it.each(["import-first", "choice-first"])("keeps local choices in persisted order (%s)", async (order) => { const manager = provider.providerSettingsManager @@ -4622,6 +4631,39 @@ describe("ClineProvider", () => { await expect(provider["getModeConfigId"]("code")).resolves.toBe(expected) }) + it.each(["imported-id", "other-id"])( + "preserves an imported choice when an overlapping write of %s fails", + async (chosenId) => { + const manager = provider.providerSettingsManager + const profiles = { + currentApiConfigName: "imported", + apiConfigs: { imported: { id: "imported-id" }, previous: { id: "previous-id" } }, + modeApiConfigs: { code: "imported-id" }, + } + await provider.setModeConfig("code", "previous-id") + let release = () => {} + const pending = new Promise((resolve) => { + release = resolve + }) + const originalStore = vi.mocked(mockContext.secrets.store).getMockImplementation()! + const store = vi.spyOn(mockContext.secrets, "store") + store + .mockImplementationOnce(async (key, value) => { + await pending + await originalStore(key, value) + }) + .mockRejectedValueOnce(new Error("write failed")) + const imported = manager.import(profiles, () => provider.adoptModeConfigIds(profiles.modeApiConfigs)) + await vi.waitFor(() => expect(store).toHaveBeenCalledOnce()) + const failed = expect(provider.setModeConfig("code", chosenId)).rejects.toThrow("write failed") + release() + await imported + await failed + await expect(manager.getModeConfigId("code")).resolves.toBe("imported-id") + await expect(provider["getModeConfigId"]("code")).resolves.toBe("imported-id") + }, + ) + it("prefers this window's mode profile over one another window saved in shared storage", async () => { const manager = provider.providerSettingsManager existingProfiles("this-window-id", "other-window-id") diff --git a/src/core/webview/__tests__/ClineProvider.sticky-mode.spec.ts b/src/core/webview/__tests__/ClineProvider.sticky-mode.spec.ts index 47fcfd11f0..4130f13b2f 100644 --- a/src/core/webview/__tests__/ClineProvider.sticky-mode.spec.ts +++ b/src/core/webview/__tests__/ClineProvider.sticky-mode.spec.ts @@ -747,12 +747,16 @@ describe("ClineProvider - Sticky Mode", () => { const architectConfigId = provider.getProviderProfileEntry("architect-config")?.id // Associate configs with modes - await provider.providerSettingsManager.setModeConfig("code", codeConfigId!) - await provider.providerSettingsManager.setModeConfig("architect", architectConfigId!) + await provider.setModeConfig("code", codeConfigId!) + await provider.setModeConfig("architect", architectConfigId!) // Start in code mode with code config await provider.handleModeSwitch("code") + const stateBeforeRestore = await provider.getState() + expect(stateBeforeRestore.currentApiConfigName).toBe("code-config") + expect(stateBeforeRestore.apiConfiguration.apiProvider).toBe("anthropic") + // Create a history item with architect mode const historyItem: HistoryItem = { id: "test-task-id", diff --git a/src/extension/__tests__/api-configuration.spec.ts b/src/extension/__tests__/api-configuration.spec.ts index b093eb2be2..bcd7569da7 100644 --- a/src/extension/__tests__/api-configuration.spec.ts +++ b/src/extension/__tests__/api-configuration.spec.ts @@ -28,6 +28,7 @@ describe("API - configuration", () => { ]), }, localModeConfigIds: new Map(), + modeConfigWriteOwners: new Map(), modeConfigWrites: new Map>(), initialModeConfigIds: Promise.resolve({}), setModeConfig: ClineProvider.prototype.setModeConfig, From 6a25b6e3e42a18101acb616e85f6dbd9f67f4937 Mon Sep 17 00:00:00 2001 From: Elliott de Launay Date: Wed, 11 Nov 2026 00:37:55 +0000 Subject: [PATCH 11/30] fix: preserve mode defaults when opening snapshot fails --- src/core/webview/ClineProvider.ts | 6 +++-- .../webview/__tests__/ClineProvider.spec.ts | 25 +++++++++++++++++++ 2 files changed, 29 insertions(+), 2 deletions(-) diff --git a/src/core/webview/ClineProvider.ts b/src/core/webview/ClineProvider.ts index e7a8894d75..c962e650e1 100644 --- a/src/core/webview/ClineProvider.ts +++ b/src/core/webview/ClineProvider.ts @@ -2151,8 +2151,10 @@ export class ClineProvider } else { // The task will continue with the current/default configuration. } - } else { - // If no saved config for this mode, save current config as default. + } else if ((await this.initialModeConfigIds) !== undefined) { + if (signal?.aborted) return + // Only seed a default when the opening snapshot was readable. + // An unreadable snapshot must not let the current profile overwrite a saved default. const currentApiConfigNameAfter = this.getGlobalState("currentApiConfigName") if (currentApiConfigNameAfter) { diff --git a/src/core/webview/__tests__/ClineProvider.spec.ts b/src/core/webview/__tests__/ClineProvider.spec.ts index 3c8a671dd5..6a4d174e17 100644 --- a/src/core/webview/__tests__/ClineProvider.spec.ts +++ b/src/core/webview/__tests__/ClineProvider.spec.ts @@ -4521,6 +4521,31 @@ describe("ClineProvider", () => { } }) + it.each([false, true])( + "only seeds an absent mode default after a readable opening snapshot (read failure: %s)", + async (fails) => { + const manager = provider.providerSettingsManager + await manager.import({ + currentApiConfigName: "current", + apiConfigs: { current: { id: "current-id" }, saved: { id: "saved-id" } }, + modeApiConfigs: fails ? { code: "saved-id" } : {}, + }) + await provider.contextProxy.setValue("currentApiConfigName", "current") + const snapshot = vi.spyOn(manager, "getModeConfigIds") + if (fails) snapshot.mockRejectedValueOnce(new Error("temporarily unreadable")) + provider["captureInitialModeConfigIds"]() + await provider["initialModeConfigIds"] + + // Storage has recovered by the time the mode switch reads profiles and could write a default. + const write = vi.spyOn(manager, "setModeConfig") + await provider["handleModeSwitchUnlocked"]("code", null) + + expect(write).toHaveBeenCalledTimes(fails ? 0 : 1) + await expect(manager.getModeConfigId("code")).resolves.toBe(fails ? "saved-id" : "current-id") + expect(provider["getGlobalState"]("currentApiConfigName")).toBe("current") + }, + ) + it.each(["snapshot", "profiles"])("stops a cancelled mode switch during %s lookup", async (stage) => { let release = () => {} const pending = new Promise((resolve) => { From 4524dec61f206a8afc7657d1acf2bbf54a6dd56f Mon Sep 17 00:00:00 2001 From: Elliott de Launay Date: Wed, 11 Nov 2026 00:48:03 +0000 Subject: [PATCH 12/30] fix: share mode profile choices across window tabs and preserve shared defaults --- src/core/webview/ClineProvider.ts | 52 +++++++-- .../webview/__tests__/ClineProvider.spec.ts | 106 ++++++++++++++++++ 2 files changed, 146 insertions(+), 12 deletions(-) diff --git a/src/core/webview/ClineProvider.ts b/src/core/webview/ClineProvider.ts index c962e650e1..aed9f14550 100644 --- a/src/core/webview/ClineProvider.ts +++ b/src/core/webview/ClineProvider.ts @@ -424,19 +424,38 @@ export class ClineProvider * Mode -> profile id choices made by this window. The persisted mode map in * `providerSettingsManager` is shared by every VS Code window, so reading it * alone lets another window's profile selection leak into this window's tasks. + * The window's focus tracker is shared by sidebar and tab providers, so it keys their shared choices. */ - private readonly localModeConfigIds = new Map() - private readonly modeConfigWriteOwners = new Map() + private static readonly modeProfilesByWindow = new WeakMap() - /** - * The shared mode map as it was when this window opened. Modes this window has not changed - * resolve against it, so another window's later selection cannot reach this window's tasks - * (including delegated subtasks). `undefined` when the map could not be read. - */ - private initialModeConfigIds: Promise | undefined> = Promise.resolve({}) + private modeProfileState = { + localIds: new Map(), + writeOwners: new Map(), + writes: new Map>(), + // Capture the shared map once when the window opens; late tabs reuse that snapshot. + // Undefined means the opening snapshot failed, rather than an empty mapping. + initialIds: Promise.resolve | undefined>({}), + } + + private get localModeConfigIds() { + return this.modeProfileState.localIds + } + + private get modeConfigWriteOwners() { + return this.modeProfileState.writeOwners + } - /** Serialize each mode’s local choice and persisted write, including failure rollback. */ - private readonly modeConfigWrites = new Map>() + private get modeConfigWrites() { + return this.modeProfileState.writes + } + + private get initialModeConfigIds() { + return this.modeProfileState.initialIds + } + + private set initialModeConfigIds(ids: Promise | undefined>) { + this.modeProfileState.initialIds = ids + } constructor( readonly context: vscode.ExtensionContext, @@ -475,7 +494,13 @@ export class ClineProvider this._workspaceTracker = new WorkspaceTracker(this) this.providerSettingsManager = new ProviderSettingsManager(this.context) - this.captureInitialModeConfigIds() + const windowModeProfiles = ClineProvider.modeProfilesByWindow.get(webviewFocusTracker) + if (windowModeProfiles) { + this.modeProfileState = windowModeProfiles + } else { + ClineProvider.modeProfilesByWindow.set(webviewFocusTracker, this.modeProfileState) + this.captureInitialModeConfigIds() + } this.customModesManager = new CustomModesManager(this.context, async () => { await this.postStateToWebviewWithoutClineMessages() @@ -2161,7 +2186,10 @@ export class ClineProvider const config = listApiConfig.find((c) => c.name === currentApiConfigNameAfter) if (config?.id) { - await this.setModeConfig(newMode, config.id) + const sharedConfigId = await this.providerSettingsManager.getModeConfigId(newMode) + if (signal?.aborted) return + // Keep this window's current profile without replacing another window's saved default. + if (sharedConfigId === undefined) await this.setModeConfig(newMode, config.id) } } } diff --git a/src/core/webview/__tests__/ClineProvider.spec.ts b/src/core/webview/__tests__/ClineProvider.spec.ts index 6a4d174e17..80ea0f81d9 100644 --- a/src/core/webview/__tests__/ClineProvider.spec.ts +++ b/src/core/webview/__tests__/ClineProvider.spec.ts @@ -4546,6 +4546,112 @@ describe("ClineProvider", () => { }, ) + it.each([false, true])( + "preserves shared defaults written after this window opened (shared mapping exists: %s)", + async (hasSharedMapping) => { + const manager = provider.providerSettingsManager + provider["initialModeConfigIds"] = Promise.resolve({}) + await manager.import({ + currentApiConfigName: "current", + apiConfigs: { current: { id: "current-id" }, other: { id: "other-id" } }, + modeApiConfigs: hasSharedMapping ? { code: "other-id" } : {}, + }) + await provider.contextProxy.setValue("currentApiConfigName", "current") + const write = vi.spyOn(manager, "setModeConfig") + const activate = vi.spyOn(manager, "activateProfile") + + await provider["handleModeSwitchUnlocked"]("code", null) + + expect(write).toHaveBeenCalledTimes(hasSharedMapping ? 0 : 1) + expect(activate).not.toHaveBeenCalled() + await expect(manager.getModeConfigId("code")).resolves.toBe( + hasSharedMapping ? "other-id" : "current-id", + ) + expect(provider["getGlobalState"]("currentApiConfigName")).toBe("current") + }, + ) + + it.each(["snapshot", "local"])("shares the window's %s choice with late-opening tabs", async (source) => { + provider["initialModeConfigIds"] = Promise.resolve({ code: "opened-id" }) + if (source === "local") provider.adoptModeConfigIds({ code: "local-id" }) + const snapshot = vi + .spyOn(ProviderSettingsManager.prototype, "getModeConfigIds") + .mockResolvedValue({ code: "other-window-id" }) + const tab = new ClineProvider( + mockContext, + mockOutputChannel, + "editor", + provider.contextProxy, + provider.webviewFocusTracker, + ) + try { + expect(snapshot).not.toHaveBeenCalled() + vi.spyOn(tab.providerSettingsManager, "listConfig").mockResolvedValue([ + { name: "opened", id: "opened-id" }, + { name: "local", id: "local-id" }, + ]) + const expectedName = source === "local" ? "local" : "opened" + vi.spyOn(tab.providerSettingsManager, "getProfile").mockResolvedValue({ + name: expectedName, + id: `${expectedName}-id`, + apiProvider: providerIdentifiers.anthropic, + }) + const activate = vi.fn() + tab["activateProviderProfileUnlocked"] = activate + + await tab["handleModeSwitchUnlocked"]("code", null) + + expect(activate).toHaveBeenCalledWith( + { name: expectedName }, + { skipCurrentTaskRebuild: true }, + undefined, + ) + await expect(tab["getModeConfigId"]("code")).resolves.toBe(`${expectedName}-id`) + + // The parent double supplies only the execution context and flush methods read during delegation. + const parent = { + taskId: "tab-parent", + apiConfiguration: { apiProvider: providerIdentifiers.anthropic }, + getTaskMode: vi.fn().mockResolvedValue("architect"), + getTaskApiConfigName: vi.fn().mockResolvedValue("parent-profile"), + flushPendingToolResultsToHistory: vi.fn().mockResolvedValue(true), + } as unknown as Task + // The child double supplies the identity and run method consumed by the scheduler. + const child = { taskId: "tab-child", run: vi.fn().mockResolvedValue(undefined) } as unknown as Task + vi.spyOn(tab, "getCurrentTask").mockReturnValue(parent) + vi.spyOn(tab, "removeClineFromStack").mockResolvedValue(undefined) + const create = vi.spyOn(tab, "createTask").mockResolvedValue(child) + vi.spyOn(tab["taskHistoryStore"], "invalidate").mockResolvedValue(undefined) + vi.spyOn(tab["taskHistoryStore"], "get").mockReturnValue(undefined) + vi.spyOn(tab["taskHistoryStore"], "atomicReadAndUpdate").mockResolvedValue([]) + await tab.delegateParentAndOpenChild({ + parentTaskId: "tab-parent", + message: "Child", + initialTodos: [], + mode: "code", + }) + expect(create).toHaveBeenCalledWith( + "Child", + undefined, + parent, + expect.objectContaining({ + handoffExecutionContext: expect.objectContaining({ mode: "code", apiConfigName: expectedName }), + }), + ) + + // Later explicit choices and imports also belong to the window, in either direction. + vi.spyOn(tab.providerSettingsManager, "setModeConfig").mockResolvedValue(undefined) + await tab.setModeConfig("code", "local-id") + existingProfiles("local-id", "opened-id") + await expect(provider["getModeConfigId"]("code")).resolves.toBe("local-id") + provider.adoptModeConfigIds({ code: "opened-id" }) + await expect(tab["getModeConfigId"]("code")).resolves.toBe("opened-id") + } finally { + await tab.dispose() + snapshot.mockRestore() + } + }) + it.each(["snapshot", "profiles"])("stops a cancelled mode switch during %s lookup", async (stage) => { let release = () => {} const pending = new Promise((resolve) => { From 2a4936b5d7c94f9c2f5cafbd9ebd7241564efd2f Mon Sep 17 00:00:00 2001 From: Elliott de Launay Date: Wed, 11 Nov 2026 00:57:54 +0000 Subject: [PATCH 13/30] fix: coordinate profile reset with queued mode writes --- src/core/webview/ClineProvider.ts | 19 +++++++ .../webview/__tests__/ClineProvider.spec.ts | 50 +++++++++++++++++++ .../__tests__/api-configuration.spec.ts | 1 + 3 files changed, 70 insertions(+) diff --git a/src/core/webview/ClineProvider.ts b/src/core/webview/ClineProvider.ts index aed9f14550..8f1a722d50 100644 --- a/src/core/webview/ClineProvider.ts +++ b/src/core/webview/ClineProvider.ts @@ -432,6 +432,7 @@ export class ClineProvider localIds: new Map(), writeOwners: new Map(), writes: new Map>(), + reset: undefined as Promise | undefined, // Capture the shared map once when the window opens; late tabs reuse that snapshot. // Undefined means the opening snapshot failed, rather than an empty mapping. initialIds: Promise.resolve | undefined>({}), @@ -2243,10 +2244,13 @@ export class ClineProvider } public async setModeConfig(mode: Mode, id: string): Promise { + if (this.modeProfileState.reset) return const pending = this.modeConfigWrites.get(mode) const write = (async () => { // A failed predecessor must roll back before this operation captures its previous choice. if (pending) await pending.catch(() => {}) + // Reset invalidates queued selections before their profiles are deleted. + if (this.modeProfileState.reset) return await this.writeModeConfig(mode, id) })() this.modeConfigWrites.set(mode, write) @@ -3853,6 +3857,21 @@ export class ClineProvider return } + if (this.modeProfileState.reset) return this.modeProfileState.reset + const reset = this.resetStateAfterModeWrites() + this.modeProfileState.reset = reset + try { + await reset + } finally { + this.modeProfileState.reset = undefined + } + } + + private async resetStateAfterModeWrites(): Promise { + // Finish active writes and cancel queued ones before deleting their persisted mappings. + // The shared reset promise also blocks new selections in other tabs until reset finishes. + await Promise.allSettled([...this.modeConfigWrites.values()]) + // Log out from cloud if authenticated if (CloudService.hasInstance()) { try { diff --git a/src/core/webview/__tests__/ClineProvider.spec.ts b/src/core/webview/__tests__/ClineProvider.spec.ts index 80ea0f81d9..ecd29b7df7 100644 --- a/src/core/webview/__tests__/ClineProvider.spec.ts +++ b/src/core/webview/__tests__/ClineProvider.spec.ts @@ -4966,6 +4966,56 @@ describe("ClineProvider", () => { }, ) + it("does not restore stale mode mappings when reset overlaps two queued same-mode writes", async () => { + const { t } = await import("../../../i18n") + vi.mocked(vscode.window.showInformationMessage).mockResolvedValueOnce(t("common:answers.yes") as never) + vi.spyOn(provider, "postStateToWebview").mockResolvedValue(undefined) + vi.spyOn(provider, "postMessageToWebview").mockResolvedValue(undefined) + provider.customModesManager.resetCustomModes = vi.fn().mockResolvedValue(undefined) + const manager = provider.providerSettingsManager + await manager.import({ + currentApiConfigName: "first", + apiConfigs: { first: { id: "first-id" }, second: { id: "second-id" } }, + modeApiConfigs: {}, + }) + let release = () => {} + const pending = new Promise((resolve) => { + release = resolve + }) + const originalStore = vi.mocked(mockContext.secrets.store).getMockImplementation()! + const store = vi.spyOn(mockContext.secrets, "store").mockImplementationOnce(async (key, value) => { + await pending + await originalStore(key, value) + }) + const first = provider.setModeConfig("code", "first-id") + await vi.waitFor(() => expect(store).toHaveBeenCalledOnce()) + const second = provider.setModeConfig("code", "second-id") + const resetConfigs = vi.spyOn(manager, "resetAllConfigs") + const resetting = provider.resetState() + await vi.waitFor(() => expect(provider["modeProfileState"].reset).toBeDefined()) + // Deletion waits for the active write; another selection during reset must also be ignored. + expect(resetConfigs).not.toHaveBeenCalled() + await provider.setModeConfig("code", "second-id") + release() + await Promise.all([first, second, resetting]) + + expect(await mockContext.secrets.get(manager["secretsKey"])).toBeUndefined() + const resetId = await manager.getModeConfigId("code") + expect(["first-id", "second-id"]).not.toContain(resetId) + await expect(provider["getModeConfigId"]("code")).resolves.toBe(resetId) + expect(provider["localModeConfigIds"].has("code")).toBe(false) + + // A fresh choice after reset can still be persisted and resolved. + await manager.import({ + currentApiConfigName: "fresh", + apiConfigs: { fresh: { id: "fresh-id" } }, + modeApiConfigs: {}, + }) + await provider.setModeConfig("code", "fresh-id") + await expect(manager.getModeConfigId("code")).resolves.toBe("fresh-id") + await expect(provider["getModeConfigId"]("code")).resolves.toBe("fresh-id") + }) + it("drops local choices and re-reads the mapping when state is reset", async () => { const { t } = await import("../../../i18n") vi.mocked(vscode.window.showInformationMessage).mockResolvedValueOnce(t("common:answers.yes") as never) diff --git a/src/extension/__tests__/api-configuration.spec.ts b/src/extension/__tests__/api-configuration.spec.ts index bcd7569da7..6e1e4f0885 100644 --- a/src/extension/__tests__/api-configuration.spec.ts +++ b/src/extension/__tests__/api-configuration.spec.ts @@ -27,6 +27,7 @@ describe("API - configuration", () => { { name: "custom", id: "architect-config" }, ]), }, + modeProfileState: { reset: undefined }, localModeConfigIds: new Map(), modeConfigWriteOwners: new Map(), modeConfigWrites: new Map>(), From e20c2b296884b0ddaf6b02e07e8525e454750d79 Mon Sep 17 00:00:00 2001 From: Elliott de Launay Date: Wed, 11 Nov 2026 02:21:51 +0000 Subject: [PATCH 14/30] fix: avoid shared writes during mode restoration and cancel queued profile writes --- src/core/config/ProviderSettingsManager.ts | 4 +- .../__tests__/ProviderSettingsManager.spec.ts | 46 +++++ src/core/webview/ClineProvider.ts | 61 +++---- .../webview/__tests__/ClineProvider.spec.ts | 168 +++++++++++++++--- .../ClineProvider.sticky-mode.spec.ts | 6 + .../ClineProvider.sticky-profile.spec.ts | 1 + 6 files changed, 231 insertions(+), 55 deletions(-) diff --git a/src/core/config/ProviderSettingsManager.ts b/src/core/config/ProviderSettingsManager.ts index 058ed63483..617e7aac42 100644 --- a/src/core/config/ProviderSettingsManager.ts +++ b/src/core/config/ProviderSettingsManager.ts @@ -543,10 +543,12 @@ export class ProviderSettingsManager { /** * Set the API config for a specific mode. */ - public async setModeConfig(mode: Mode, configId: string, onPersisted?: () => void) { + public async setModeConfig(mode: Mode, configId: string, onPersisted?: () => void, signal?: AbortSignal) { try { return await this.lock(async () => { + if (signal?.aborted) return const providerProfiles = await this.load() + if (signal?.aborted) return // Ensure the per-mode config map exists if (!providerProfiles.modeApiConfigs) { providerProfiles.modeApiConfigs = {} diff --git a/src/core/config/__tests__/ProviderSettingsManager.spec.ts b/src/core/config/__tests__/ProviderSettingsManager.spec.ts index 66f42b9b40..5a7128a3ce 100644 --- a/src/core/config/__tests__/ProviderSettingsManager.spec.ts +++ b/src/core/config/__tests__/ProviderSettingsManager.spec.ts @@ -119,6 +119,52 @@ describe("ProviderSettingsManager", () => { expect(published).toHaveBeenCalledTimes(fails ? 0 : 1) }) + it.each([false, true])("checks cancellation after waiting for the storage lock (cancelled: %s)", async (cancel) => { + let release = () => {} + const pending = new Promise((resolve) => { + release = resolve + }) + mockSecrets.store.mockImplementationOnce(async () => { + await pending + }) + const imported = providerSettingsManager.import({ + currentApiConfigName: "default", + apiConfigs: {}, + modeApiConfigs: {}, + }) + await vi.waitFor(() => expect(mockSecrets.store).toHaveBeenCalledOnce()) + const controller = new AbortController() + const published = vi.fn() + const selected = providerSettingsManager.setModeConfig("code", "selected-id", published, controller.signal) + if (cancel) controller.abort() + release() + await Promise.all([imported, selected]) + + expect(mockSecrets.store).toHaveBeenCalledTimes(cancel ? 1 : 2) + expect(published).toHaveBeenCalledTimes(cancel ? 0 : 1) + }) + + it.each([false, true])("checks cancellation after loading profiles (cancelled: %s)", async (cancel) => { + let release = () => {} + const pending = new Promise((resolve) => { + release = resolve + }) + mockSecrets.get.mockImplementationOnce(async () => { + await pending + return null + }) + const controller = new AbortController() + const published = vi.fn() + const selected = providerSettingsManager.setModeConfig("code", "selected-id", published, controller.signal) + await vi.waitFor(() => expect(mockSecrets.get).toHaveBeenCalledOnce()) + if (cancel) controller.abort() + release() + await selected + + expect(mockSecrets.store).toHaveBeenCalledTimes(cancel ? 0 : 1) + expect(published).toHaveBeenCalledTimes(cancel ? 0 : 1) + }) + describe("initialize", () => { it("should not write to storage when secrets.get returns null", async () => { // Mock readConfig to return null diff --git a/src/core/webview/ClineProvider.ts b/src/core/webview/ClineProvider.ts index 8f1a722d50..d3d36f5d22 100644 --- a/src/core/webview/ClineProvider.ts +++ b/src/core/webview/ClineProvider.ts @@ -2168,7 +2168,7 @@ export class ClineProvider if (hasActualSettings) { await this.activateProviderProfileUnlocked( { name: profile.name }, - targetTask === null ? { skipCurrentTaskRebuild: true } : undefined, + { persistModeConfig: false, skipCurrentTaskRebuild: targetTask === null }, signal, ) } else { @@ -2177,24 +2177,9 @@ export class ClineProvider } else { // The task will continue with the current/default configuration. } - } else if ((await this.initialModeConfigIds) !== undefined) { - if (signal?.aborted) return - // Only seed a default when the opening snapshot was readable. - // An unreadable snapshot must not let the current profile overwrite a saved default. - const currentApiConfigNameAfter = this.getGlobalState("currentApiConfigName") - - if (currentApiConfigNameAfter) { - const config = listApiConfig.find((c) => c.name === currentApiConfigNameAfter) - - if (config?.id) { - const sharedConfigId = await this.providerSettingsManager.getModeConfigId(newMode) - if (signal?.aborted) return - // Keep this window's current profile without replacing another window's saved default. - if (sharedConfigId === undefined) await this.setModeConfig(newMode, config.id) - } - } } + if (signal?.aborted) return if (targetTask !== null) { await this.postStateToWebview() } @@ -2243,15 +2228,15 @@ export class ClineProvider } } - public async setModeConfig(mode: Mode, id: string): Promise { - if (this.modeProfileState.reset) return + public async setModeConfig(mode: Mode, id: string, signal?: AbortSignal): Promise { + if (this.modeProfileState.reset || signal?.aborted) return const pending = this.modeConfigWrites.get(mode) const write = (async () => { // A failed predecessor must roll back before this operation captures its previous choice. if (pending) await pending.catch(() => {}) // Reset invalidates queued selections before their profiles are deleted. - if (this.modeProfileState.reset) return - await this.writeModeConfig(mode, id) + if (this.modeProfileState.reset || signal?.aborted) return + await this.writeModeConfig(mode, id, signal) })() this.modeConfigWrites.set(mode, write) try { @@ -2261,24 +2246,31 @@ export class ClineProvider } } - private async writeModeConfig(mode: Mode, id: string): Promise { + private async writeModeConfig(mode: Mode, id: string, signal?: AbortSignal): Promise { const previousId = this.localModeConfigIds.get(mode) const owner = Symbol() this.modeConfigWriteOwners.set(mode, owner) this.localModeConfigIds.set(mode, id) + let persisted = false + const rollback = () => { + if (this.modeConfigWriteOwners.get(mode) !== owner) return + if (previousId === undefined) this.localModeConfigIds.delete(mode) + else this.localModeConfigIds.set(mode, previousId) + } + const onPersisted = () => { + persisted = true + // An import may have adopted another choice while this write waited for the storage lock. + this.localModeConfigIds.set(mode, id) + } try { - await this.providerSettingsManager.setModeConfig(mode, id, () => { - // An import may have adopted another choice while this write waited for the storage lock. - this.localModeConfigIds.set(mode, id) - }) + if (signal) await this.providerSettingsManager.setModeConfig(mode, id, onPersisted, signal) + else await this.providerSettingsManager.setModeConfig(mode, id, onPersisted) } catch (error) { // Only roll back our optimistic update; an import may have adopted even the same ID. - if (this.modeConfigWriteOwners.get(mode) === owner) { - if (previousId === undefined) this.localModeConfigIds.delete(mode) - else this.localModeConfigIds.set(mode, previousId) - } + rollback() throw error } finally { + if (signal?.aborted && !persisted) rollback() if (this.modeConfigWriteOwners.get(mode) === owner) this.modeConfigWriteOwners.delete(mode) } } @@ -2488,7 +2480,7 @@ export class ClineProvider const activationResults = await Promise.allSettled([ this.updateGlobalState("listApiConfigMeta", await this.providerSettingsManager.listConfig()), this.updateGlobalState("currentApiConfigName", name), - this.setModeConfig(mode, id), + this.setModeConfig(mode, id, signal), this.contextProxy.setProviderSettings(providerSettings), ]) const failedActivation = activationResults.find( @@ -2593,6 +2585,7 @@ export class ClineProvider }, signal?: AbortSignal, ): Promise { + if (signal?.aborted) return const { name, id, ...providerSettings } = await this.providerSettingsManager.activateProfile(args) if (signal?.aborted) return @@ -2610,11 +2603,13 @@ export class ClineProvider ]) } + if (signal?.aborted) return const { mode } = await this.getState() if (id && persistModeConfig) { - await this.setModeConfig(mode, id) + await this.setModeConfig(mode, id, signal) } + if (signal?.aborted) return // Change the provider for the current task. const expectedCurrentTaskId = options?.expectedCurrentTaskId @@ -2633,10 +2628,12 @@ export class ClineProvider }) } + if (signal?.aborted) return if (!skipCurrentTaskRebuild) { await this.postStateToWebview() } + if (signal?.aborted) return if (providerSettings.apiProvider && !skipCurrentTaskRebuild) { this.emit(RooCodeEventName.ProviderProfileChanged, { name, provider: providerSettings.apiProvider }) } diff --git a/src/core/webview/__tests__/ClineProvider.spec.ts b/src/core/webview/__tests__/ClineProvider.spec.ts index ecd29b7df7..4a2df7ed40 100644 --- a/src/core/webview/__tests__/ClineProvider.spec.ts +++ b/src/core/webview/__tests__/ClineProvider.spec.ts @@ -4522,7 +4522,7 @@ describe("ClineProvider", () => { }) it.each([false, true])( - "only seeds an absent mode default after a readable opening snapshot (read failure: %s)", + "keeps the current profile without seeding a shared default (read failure: %s)", async (fails) => { const manager = provider.providerSettingsManager await manager.import({ @@ -4540,8 +4540,8 @@ describe("ClineProvider", () => { const write = vi.spyOn(manager, "setModeConfig") await provider["handleModeSwitchUnlocked"]("code", null) - expect(write).toHaveBeenCalledTimes(fails ? 0 : 1) - await expect(manager.getModeConfigId("code")).resolves.toBe(fails ? "saved-id" : "current-id") + expect(write).not.toHaveBeenCalled() + await expect(manager.getModeConfigId("code")).resolves.toBe(fails ? "saved-id" : undefined) expect(provider["getGlobalState"]("currentApiConfigName")).toBe("current") }, ) @@ -4562,11 +4562,9 @@ describe("ClineProvider", () => { await provider["handleModeSwitchUnlocked"]("code", null) - expect(write).toHaveBeenCalledTimes(hasSharedMapping ? 0 : 1) + expect(write).not.toHaveBeenCalled() expect(activate).not.toHaveBeenCalled() - await expect(manager.getModeConfigId("code")).resolves.toBe( - hasSharedMapping ? "other-id" : "current-id", - ) + await expect(manager.getModeConfigId("code")).resolves.toBe(hasSharedMapping ? "other-id" : undefined) expect(provider["getGlobalState"]("currentApiConfigName")).toBe("current") }, ) @@ -4603,7 +4601,7 @@ describe("ClineProvider", () => { expect(activate).toHaveBeenCalledWith( { name: expectedName }, - { skipCurrentTaskRebuild: true }, + { persistModeConfig: false, skipCurrentTaskRebuild: true }, undefined, ) await expect(tab["getModeConfigId"]("code")).resolves.toBe(`${expectedName}-id`) @@ -4652,6 +4650,137 @@ describe("ClineProvider", () => { } }) + it("restores a cached mode profile without overwriting another window's shared choice", async () => { + const manager = provider.providerSettingsManager + await manager.import({ + currentApiConfigName: "other", + apiConfigs: { + local: { id: "local-id", apiProvider: providerIdentifiers.anthropic }, + other: { id: "other-id", apiProvider: providerIdentifiers.openai }, + }, + modeApiConfigs: { code: "other-id" }, + }) + provider.adoptModeConfigIds({ code: "local-id" }) + const write = vi.spyOn(manager, "setModeConfig") + const activate = vi.spyOn(manager, "activateProfile") + + await provider["handleModeSwitchUnlocked"]("code", null) + + expect(activate).toHaveBeenCalledWith({ name: "local" }) + expect(write).not.toHaveBeenCalled() + await expect(manager.getModeConfigId("code")).resolves.toBe("other-id") + await expect(provider["getModeConfigId"]("code")).resolves.toBe("local-id") + }) + + it.each([false, true])( + "does not seed an unmapped mode across a delayed read (cancelled: %s)", + async (cancel) => { + const manager = provider.providerSettingsManager + provider["initialModeConfigIds"] = Promise.resolve({}) + let release = () => {} + const pending = new Promise((resolve) => { + release = resolve + }) + const list = vi.spyOn(manager, "listConfig").mockImplementationOnce(async () => { + await pending + return [{ name: "current-config", id: "current-id" }] + }) + // Seeding no longer reads shared mappings, so there is no check/write gap to race. + const lookup = vi.spyOn(manager, "getModeConfigId") + const write = vi.spyOn(manager, "setModeConfig") + const controller = new AbortController() + const switched = provider["handleModeSwitchUnlocked"]("code", null, controller.signal) + await vi.waitFor(() => expect(list).toHaveBeenCalledOnce()) + if (cancel) controller.abort() + await manager.import({ + currentApiConfigName: "other", + apiConfigs: { other: { id: "other-id" } }, + modeApiConfigs: { code: "other-id" }, + }) + release() + await switched + + expect(lookup).not.toHaveBeenCalled() + expect(write).not.toHaveBeenCalled() + expect(provider["localModeConfigIds"].has("code")).toBe(false) + await expect(manager.getModeConfigId("code")).resolves.toBe("other-id") + }, + ) + + it.each([false, true])("handles a mode write waiting for the storage lock (cancelled: %s)", async (cancel) => { + const manager = provider.providerSettingsManager + let release = () => {} + const pending = new Promise((resolve) => { + release = resolve + }) + const originalStore = vi.mocked(mockContext.secrets.store).getMockImplementation()! + const store = vi.spyOn(mockContext.secrets, "store").mockImplementationOnce(async (key, value) => { + await pending + await originalStore(key, value) + }) + const imported = manager.import({ + currentApiConfigName: "imported", + apiConfigs: { imported: { id: "imported-id" }, selected: { id: "selected-id" } }, + modeApiConfigs: { code: "imported-id" }, + }) + await vi.waitFor(() => expect(store).toHaveBeenCalledOnce()) + const controller = new AbortController() + const write = provider.setModeConfig("code", "selected-id", controller.signal) + expect(provider["localModeConfigIds"].get("code")).toBe("selected-id") + if (cancel) controller.abort() + release() + await Promise.all([imported, write]) + + await expect(manager.getModeConfigId("code")).resolves.toBe(cancel ? "imported-id" : "selected-id") + expect(provider["localModeConfigIds"].get("code")).toBe(cancel ? undefined : "selected-id") + }) + + it.each(["queued", "persisting"])( + "stops cancelled activation work when its mode write is %s", + async (stage) => { + await provider.setValue("mode", "code") + const manager = provider.providerSettingsManager + vi.spyOn(manager, "activateProfile").mockResolvedValue({ + name: "selected", + id: "selected-id", + apiProvider: providerIdentifiers.anthropic, + }) + let release = () => {} + const pending = new Promise((resolve) => { + release = resolve + }) + const write = vi + .spyOn(manager, "setModeConfig") + .mockImplementationOnce(async (_mode, _id, onPersisted) => { + await pending + onPersisted?.() + }) + const select = vi.spyOn(provider, "setModeConfig") + const preceding = stage === "queued" ? provider.setModeConfig("code", "previous-id") : Promise.resolve() + const rebuild = vi.fn(provider["updateTaskApiHandlerIfNeeded"].bind(provider)) + provider["updateTaskApiHandlerIfNeeded"] = rebuild + const sticky = vi.fn(provider["persistStickyProviderProfileToCurrentTask"].bind(provider)) + provider["persistStickyProviderProfileToCurrentTask"] = sticky + const controller = new AbortController() + const activation = provider["activateProviderProfileUnlocked"]( + { name: "selected" }, + { skipCurrentTaskRebuild: true }, + controller.signal, + ) + await vi.waitFor(() => expect(select).toHaveBeenCalledTimes(stage === "queued" ? 2 : 1)) + controller.abort() + release() + await Promise.all([preceding, activation]) + + expect(write).toHaveBeenCalledOnce() + expect(provider["localModeConfigIds"].get("code")).toBe( + stage === "queued" ? "previous-id" : "selected-id", + ) + expect(rebuild).not.toHaveBeenCalled() + expect(sticky).not.toHaveBeenCalled() + }, + ) + it.each(["snapshot", "profiles"])("stops a cancelled mode switch during %s lookup", async (stage) => { let release = () => {} const pending = new Promise((resolve) => { @@ -5036,7 +5165,7 @@ describe("ClineProvider", () => { }) }) - it("saves current config when switching to mode without config", async () => { + it("keeps current config without saving a shared default for an unmapped mode", async () => { await provider.resolveWebviewView(mockWebviewView) const messageHandler = (mockWebviewView.webview.onDidReceiveMessage as any).mock.calls[0][0] @@ -5055,12 +5184,8 @@ describe("ClineProvider", () => { // Switch to architect mode await messageHandler({ type: "mode", text: "architect" }) - // Should save current config as default for architect mode - expect(provider.providerSettingsManager.setModeConfig).toHaveBeenCalledWith( - "architect", - "current-id", - expect.any(Function), - ) + // An implicit mode switch must not seed shared storage. + expect(provider.providerSettingsManager.setModeConfig).not.toHaveBeenCalled() }) it("saves config as default for current mode when loading config", async () => { @@ -5091,6 +5216,7 @@ describe("ClineProvider", () => { "architect", "new-id", expect.any(Function), + expect.any(AbortSignal), ) }) @@ -5122,6 +5248,7 @@ describe("ClineProvider", () => { "architect", "config-id-123", expect.any(Function), + expect.any(AbortSignal), ) // Ensure the `activateProfile` method was called with the correct ID @@ -5306,6 +5433,7 @@ describe("ClineProvider", () => { "code", "test-id", expect.any(Function), + expect.any(AbortSignal), ) }) @@ -5662,7 +5790,7 @@ describe("ClineProvider", () => { expect(mockPostMessage).toHaveBeenCalledWith(expect.objectContaining({ type: "state" })) }) - test("saves current config when switching to mode without config", async () => { + test("keeps current config without saving a shared default for an unmapped mode", async () => { ;(provider as any).providerSettingsManager = { getModeConfigId: vi.fn().mockResolvedValue(undefined), listConfig: vi @@ -5687,12 +5815,8 @@ describe("ClineProvider", () => { // Verify mode was updated expect(mockContext.globalState.update).toHaveBeenCalledWith("mode", "architect") - // Verify current config was saved as default for new mode - expect(provider.providerSettingsManager.setModeConfig).toHaveBeenCalledWith( - "architect", - "current-id", - expect.any(Function), - ) + // An implicit mode switch must not seed shared storage. + expect(provider.providerSettingsManager.setModeConfig).not.toHaveBeenCalled() // Verify state was posted to webview expect(mockPostMessage).toHaveBeenCalledWith(expect.objectContaining({ type: "state" })) diff --git a/src/core/webview/__tests__/ClineProvider.sticky-mode.spec.ts b/src/core/webview/__tests__/ClineProvider.sticky-mode.spec.ts index 4130f13b2f..0d54c1464c 100644 --- a/src/core/webview/__tests__/ClineProvider.sticky-mode.spec.ts +++ b/src/core/webview/__tests__/ClineProvider.sticky-mode.spec.ts @@ -771,8 +771,14 @@ describe("ClineProvider - Sticky Mode", () => { mode: "architect", // Task was created in architect mode } + // Another window changes the shared architect default after this window chose its profile. + await provider.providerSettingsManager.setModeConfig("architect", codeConfigId!) + const activate = vi.spyOn(provider.providerSettingsManager, "activateProfile") + // Restore the task from history await provider.createTaskWithHistoryItem(historyItem) + expect(activate).toHaveBeenCalledWith({ name: "architect-config" }) + await expect(provider.providerSettingsManager.getModeConfigId("architect")).resolves.toBe(codeConfigId) // Verify that the mode was restored const state = await provider.getState() diff --git a/src/core/webview/__tests__/ClineProvider.sticky-profile.spec.ts b/src/core/webview/__tests__/ClineProvider.sticky-profile.spec.ts index e508fbd2de..53204ebb6e 100644 --- a/src/core/webview/__tests__/ClineProvider.sticky-profile.spec.ts +++ b/src/core/webview/__tests__/ClineProvider.sticky-profile.spec.ts @@ -460,6 +460,7 @@ describe("ClineProvider - Sticky Provider Profile", () => { "architect", "new-profile-id", expect.any(Function), + expect.any(AbortSignal), ) } else { expect(setModeConfigSpy).not.toHaveBeenCalled() From a59b92fe6905e3c1e41726d2bc3dad8d7528cb95 Mon Sep 17 00:00:00 2001 From: Elliott de Launay Date: Wed, 11 Nov 2026 03:54:57 +0000 Subject: [PATCH 15/30] fix: report cancelled mode writes and abort profile activations on disposal --- src/core/config/ProviderSettingsManager.ts | 9 +- .../__tests__/ProviderSettingsManager.spec.ts | 36 ++++- src/core/webview/ClineProvider.ts | 75 ++++++--- .../ClineProvider.apiHandlerRebuild.spec.ts | 5 +- .../webview/__tests__/ClineProvider.spec.ts | 150 ++++++++++++++++-- .../ClineProvider.sticky-mode.spec.ts | 2 +- .../__tests__/api-configuration.spec.ts | 56 ++++++- src/extension/api.ts | 11 +- 8 files changed, 303 insertions(+), 41 deletions(-) diff --git a/src/core/config/ProviderSettingsManager.ts b/src/core/config/ProviderSettingsManager.ts index 617e7aac42..e382c4a827 100644 --- a/src/core/config/ProviderSettingsManager.ts +++ b/src/core/config/ProviderSettingsManager.ts @@ -487,12 +487,17 @@ export class ProviderSettingsManager { */ public async activateProfile( params: { name: string } | { id: string }, + signal?: AbortSignal, ): Promise { + signal?.throwIfAborted() const { name, ...providerSettings } = await this.getProfile(params) + signal?.throwIfAborted() try { return await this.lock(async () => { + signal?.throwIfAborted() const providerProfiles = await this.load() + signal?.throwIfAborted() providerProfiles.currentApiConfigName = name await this.store(providerProfiles) return { name, ...providerSettings } @@ -546,9 +551,9 @@ export class ProviderSettingsManager { public async setModeConfig(mode: Mode, configId: string, onPersisted?: () => void, signal?: AbortSignal) { try { return await this.lock(async () => { - if (signal?.aborted) return + signal?.throwIfAborted() const providerProfiles = await this.load() - if (signal?.aborted) return + signal?.throwIfAborted() // Ensure the per-mode config map exists if (!providerProfiles.modeApiConfigs) { providerProfiles.modeApiConfigs = {} diff --git a/src/core/config/__tests__/ProviderSettingsManager.spec.ts b/src/core/config/__tests__/ProviderSettingsManager.spec.ts index 5a7128a3ce..ac5eef271c 100644 --- a/src/core/config/__tests__/ProviderSettingsManager.spec.ts +++ b/src/core/config/__tests__/ProviderSettingsManager.spec.ts @@ -133,13 +133,17 @@ describe("ProviderSettingsManager", () => { modeApiConfigs: {}, }) await vi.waitFor(() => expect(mockSecrets.store).toHaveBeenCalledOnce()) + // Exclude the constructor's initialization read from the selected write's read count. + mockSecrets.get.mockClear() const controller = new AbortController() const published = vi.fn() const selected = providerSettingsManager.setModeConfig("code", "selected-id", published, controller.signal) if (cancel) controller.abort() release() - await Promise.all([imported, selected]) + const result = cancel ? expect(selected).rejects.toThrow("aborted") : expect(selected).resolves.toBeUndefined() + await Promise.all([imported, result]) + expect(mockSecrets.get).toHaveBeenCalledTimes(cancel ? 0 : 1) expect(mockSecrets.store).toHaveBeenCalledTimes(cancel ? 1 : 2) expect(published).toHaveBeenCalledTimes(cancel ? 0 : 1) }) @@ -158,13 +162,41 @@ describe("ProviderSettingsManager", () => { const selected = providerSettingsManager.setModeConfig("code", "selected-id", published, controller.signal) await vi.waitFor(() => expect(mockSecrets.get).toHaveBeenCalledOnce()) if (cancel) controller.abort() + const result = cancel ? expect(selected).rejects.toThrow("aborted") : expect(selected).resolves.toBeUndefined() release() - await selected + await result expect(mockSecrets.store).toHaveBeenCalledTimes(cancel ? 0 : 1) expect(published).toHaveBeenCalledTimes(cancel ? 0 : 1) }) + it.each([false, true])("cancels profile activation waiting for storage (cancelled: %s)", async (cancel) => { + let release = () => {} + const pending = new Promise((resolve) => { + release = resolve + }) + mockSecrets.store.mockImplementationOnce(async () => { + await pending + }) + const imported = providerSettingsManager.import({ + currentApiConfigName: "default", + apiConfigs: {}, + modeApiConfigs: {}, + }) + await vi.waitFor(() => expect(mockSecrets.store).toHaveBeenCalledOnce()) + vi.spyOn(providerSettingsManager, "getProfile").mockResolvedValue({ name: "selected", id: "selected-id" }) + const controller = new AbortController() + const selected = providerSettingsManager.activateProfile({ name: "selected" }, controller.signal) + if (cancel) controller.abort() + const result = cancel + ? expect(selected).rejects.toThrow("aborted") + : expect(selected).resolves.toMatchObject({ name: "selected", id: "selected-id" }) + release() + await Promise.all([imported, result]) + + expect(mockSecrets.store).toHaveBeenCalledTimes(cancel ? 1 : 2) + }) + describe("initialize", () => { it("should not write to storage when secrets.get returns null", async () => { // Mock readConfig to return null diff --git a/src/core/webview/ClineProvider.ts b/src/core/webview/ClineProvider.ts index d3d36f5d22..ae69d7a546 100644 --- a/src/core/webview/ClineProvider.ts +++ b/src/core/webview/ClineProvider.ts @@ -328,6 +328,7 @@ export class ClineProvider public readonly taskHistoryStore: TaskHistoryStore private taskHistoryStoreInitialized = false public static readonly PENDING_OPERATION_TIMEOUT_MS = 30000 // 30 seconds + private readonly profileMutationAbortController = new AbortController() private providerProfileMutationQueue = Promise.resolve() private historyTaskCreationQueue = Promise.resolve() @@ -345,20 +346,26 @@ export class ClineProvider options: { runToCompletion?: boolean } = {}, ): Promise { const controller = new AbortController() + const signal = AbortSignal.any([controller.signal, this.profileMutationAbortController.signal]) + const invoke = () => { + signal.throwIfAborted() + return fn(signal) + } // Run fn after either outcome so a rejected mutation never poisons the queue. - const run = this.providerProfileMutationQueue.then( - () => fn(controller.signal), - () => fn(controller.signal), - ) - const callerResult = this.withProviderProfileMutationTimeout(run, () => { - if (options.runToCompletion) { - this.log("Provider profile mutation timed out; waiting for it to finish before the next mutation") - return - } + const run = this.providerProfileMutationQueue.then(invoke, invoke) + const callerResult = this.withProviderProfileMutationTimeout( + run, + () => { + if (options.runToCompletion) { + this.log("Provider profile mutation timed out; waiting for it to finish before the next mutation") + return + } - controller.abort() - this.log("Provider profile mutation timed out; aborting in-flight mutation") - }) + controller.abort() + this.log("Provider profile mutation timed out; aborting in-flight mutation") + }, + this.profileMutationAbortController.signal, + ) void run.then( () => { @@ -386,7 +393,11 @@ export class ClineProvider return callerResult } - private withProviderProfileMutationTimeout(operation: Promise, onTimeout: () => void): Promise { + private withProviderProfileMutationTimeout( + operation: Promise, + onTimeout: () => void, + signal: AbortSignal, + ): Promise { let timeoutId: ReturnType | undefined const timeout = new Promise((_, reject) => { timeoutId = setTimeout(() => { @@ -394,11 +405,16 @@ export class ClineProvider reject(new Error("Provider profile mutation timed out")) }, ClineProvider.PENDING_OPERATION_TIMEOUT_MS) }) + let onAbort = () => {} + const cancelled = new Promise((_, reject) => { + onAbort = () => reject(signal.reason) + if (signal.aborted) onAbort() + else signal.addEventListener("abort", onAbort, { once: true }) + }) - return Promise.race([operation, timeout]).finally(() => { - if (timeoutId) { - clearTimeout(timeoutId) - } + return Promise.race([operation, timeout, cancelled]).finally(() => { + if (timeoutId) clearTimeout(timeoutId) + signal.removeEventListener("abort", onAbort) }) } @@ -995,6 +1011,7 @@ export class ClineProvider } this._disposed = true + this.profileMutationAbortController.abort(new Error("Provider disposed")) this._postStateToWebviewThrottled.cancel() this.stopWebviewWatchdog() this.diagnosticsRecorder.record({ boundary: "provider", phase: "start", type: "dispose" }) @@ -2229,14 +2246,19 @@ export class ClineProvider } public async setModeConfig(mode: Mode, id: string, signal?: AbortSignal): Promise { - if (this.modeProfileState.reset || signal?.aborted) return + const writeSignal = signal + ? AbortSignal.any([signal, this.profileMutationAbortController.signal]) + : this.profileMutationAbortController.signal + writeSignal.throwIfAborted() + if (this.modeProfileState.reset) throw new Error("Mode profile write cancelled by settings reset") const pending = this.modeConfigWrites.get(mode) const write = (async () => { // A failed predecessor must roll back before this operation captures its previous choice. if (pending) await pending.catch(() => {}) // Reset invalidates queued selections before their profiles are deleted. - if (this.modeProfileState.reset || signal?.aborted) return - await this.writeModeConfig(mode, id, signal) + writeSignal.throwIfAborted() + if (this.modeProfileState.reset) throw new Error("Mode profile write cancelled by settings reset") + await this.writeModeConfig(mode, id, writeSignal) })() this.modeConfigWrites.set(mode, write) try { @@ -2452,6 +2474,7 @@ export class ClineProvider activate: boolean, signal: AbortSignal, ): Promise { + signal.throwIfAborted() // TODO: Do we need to be calling `activateProfile`? It's not // clear to me what the source of truth should be; in some cases // we rely on the `ContextProxy`'s data store and in other cases @@ -2477,8 +2500,10 @@ export class ClineProvider // We should probably switch to that and verify that it works. // I left the original implementation in just to be safe. // `allSettled` so a caller that rolls back after a failure never races a write still in flight. + const profiles = await this.providerSettingsManager.listConfig() + signal.throwIfAborted() const activationResults = await Promise.allSettled([ - this.updateGlobalState("listApiConfigMeta", await this.providerSettingsManager.listConfig()), + this.updateGlobalState("listApiConfigMeta", profiles), this.updateGlobalState("currentApiConfigName", name), this.setModeConfig(mode, id, signal), this.contextProxy.setProviderSettings(providerSettings), @@ -2586,7 +2611,9 @@ export class ClineProvider signal?: AbortSignal, ): Promise { if (signal?.aborted) return - const { name, id, ...providerSettings } = await this.providerSettingsManager.activateProfile(args) + const { name, id, ...providerSettings } = signal + ? await this.providerSettingsManager.activateProfile(args, signal) + : await this.providerSettingsManager.activateProfile(args) if (signal?.aborted) return @@ -2596,8 +2623,10 @@ export class ClineProvider if (!skipCurrentTaskRebuild) { // See `upsertProviderProfile` for a description of what this is doing. + const profiles = await this.providerSettingsManager.listConfig() + signal?.throwIfAborted() await Promise.all([ - this.contextProxy.setValue("listApiConfigMeta", await this.providerSettingsManager.listConfig()), + this.contextProxy.setValue("listApiConfigMeta", profiles), this.contextProxy.setValue("currentApiConfigName", name), this.contextProxy.setProviderSettings(providerSettings), ]) diff --git a/src/core/webview/__tests__/ClineProvider.apiHandlerRebuild.spec.ts b/src/core/webview/__tests__/ClineProvider.apiHandlerRebuild.spec.ts index ca504be775..0800092bde 100644 --- a/src/core/webview/__tests__/ClineProvider.apiHandlerRebuild.spec.ts +++ b/src/core/webview/__tests__/ClineProvider.apiHandlerRebuild.spec.ts @@ -1011,7 +1011,10 @@ describe("ClineProvider - API Handler Rebuild Guard", () => { expect(setValueSpy).not.toHaveBeenCalledWith("currentApiConfigName", "ask-profile") expect(setProviderSettingsSpy).not.toHaveBeenCalled() expect(emitSpy).toHaveBeenCalledWith(RooCodeEventName.ModeChanged, "ask") - expect(provider["providerSettingsManager"].activateProfile).toHaveBeenCalledWith({ name: "ask-profile" }) + expect(provider["providerSettingsManager"].activateProfile).toHaveBeenCalledWith( + { name: "ask-profile" }, + expect.any(AbortSignal), + ) }) test("calls updateApiConfiguration when provider/model unchanged but settings differ (explicit profile switch)", async () => { diff --git a/src/core/webview/__tests__/ClineProvider.spec.ts b/src/core/webview/__tests__/ClineProvider.spec.ts index 4a2df7ed40..59019b86b1 100644 --- a/src/core/webview/__tests__/ClineProvider.spec.ts +++ b/src/core/webview/__tests__/ClineProvider.spec.ts @@ -4483,7 +4483,10 @@ describe("ClineProvider", () => { // Should load the saved config for architect mode expect(provider.providerSettingsManager.getModeConfigId).not.toHaveBeenCalled() - expect(provider.providerSettingsManager.activateProfile).toHaveBeenCalledWith({ name: "test-config" }) + expect(provider.providerSettingsManager.activateProfile).toHaveBeenCalledWith( + { name: "test-config" }, + expect.any(AbortSignal), + ) expect(mockContext.globalState.update).toHaveBeenCalledWith("currentApiConfigName", "test-config") }) @@ -4729,7 +4732,8 @@ describe("ClineProvider", () => { expect(provider["localModeConfigIds"].get("code")).toBe("selected-id") if (cancel) controller.abort() release() - await Promise.all([imported, write]) + const result = cancel ? expect(write).rejects.toThrow("aborted") : expect(write).resolves.toBeUndefined() + await Promise.all([imported, result]) await expect(manager.getModeConfigId("code")).resolves.toBe(cancel ? "imported-id" : "selected-id") expect(provider["localModeConfigIds"].get("code")).toBe(cancel ? undefined : "selected-id") @@ -4770,7 +4774,11 @@ describe("ClineProvider", () => { await vi.waitFor(() => expect(select).toHaveBeenCalledTimes(stage === "queued" ? 2 : 1)) controller.abort() release() - await Promise.all([preceding, activation]) + const result = + stage === "queued" + ? expect(activation).rejects.toThrow("aborted") + : expect(activation).resolves.toBeUndefined() + await Promise.all([preceding, result]) expect(write).toHaveBeenCalledOnce() expect(provider["localModeConfigIds"].get("code")).toBe( @@ -4781,6 +4789,114 @@ describe("ClineProvider", () => { }, ) + it("skips context writes when disposed during an activation's profile read", async () => { + vi.spyOn(provider.providerSettingsManager, "activateProfile").mockResolvedValue({ + name: "closed", + id: "closed-id", + apiProvider: providerIdentifiers.anthropic, + }) + let release = () => {} + const pending = new Promise((resolve) => { + release = resolve + }) + const list = vi.spyOn(provider.providerSettingsManager, "listConfig").mockImplementationOnce(async () => { + await pending + return [] + }) + const unlocked = vi.fn(provider["activateProviderProfileUnlocked"].bind(provider)) + provider["activateProviderProfileUnlocked"] = unlocked + const activation = expect(provider.activateProviderProfile({ name: "closed" })).rejects.toThrow( + "Provider disposed", + ) + await vi.waitFor(() => expect(list).toHaveBeenCalledOnce()) + const contextWrite = vi.spyOn(provider.contextProxy, "setValue") + const settingsWrite = vi.spyOn(provider.contextProxy, "setProviderSettings") + const run = expect(unlocked.mock.results[0].value).rejects.toThrow("Provider disposed") + await provider.dispose() + release() + await Promise.all([activation, run]) + + expect(contextWrite).not.toHaveBeenCalled() + expect(settingsWrite).not.toHaveBeenCalled() + }) + + it("invalidates a closed tab's queued activations while a reopened tab can finish its choice", async () => { + await provider.setValue("mode", "code") + const manager = provider.providerSettingsManager + await manager.import({ + currentApiConfigName: "opened", + apiConfigs: { + opened: { id: "opened-id" }, + closed: { id: "closed-id" }, + reopened: { id: "reopened-id" }, + }, + modeApiConfigs: {}, + }) + const makeTab = () => + new ClineProvider( + mockContext, + mockOutputChannel, + "editor", + provider.contextProxy, + provider.webviewFocusTracker, + ) + const tab = makeTab() + let reopened: ClineProvider | undefined + let release = () => {} + const pending = new Promise((resolve) => { + release = resolve + }) + try { + const originalStore = vi.mocked(mockContext.secrets.store).getMockImplementation()! + const store = vi.spyOn(mockContext.secrets, "store").mockImplementationOnce(async (key, value) => { + await pending + await originalStore(key, value) + }) + const first = provider.setModeConfig("code", "opened-id") + await vi.waitFor(() => expect(store).toHaveBeenCalledOnce()) + const activate = vi.spyOn(tab.providerSettingsManager, "activateProfile").mockResolvedValue({ + name: "closed", + id: "closed-id", + apiProvider: providerIdentifiers.anthropic, + }) + const write = vi.spyOn(tab.providerSettingsManager, "setModeConfig") + const select = vi.spyOn(tab, "setModeConfig") + const rebuild = vi.fn(tab["updateTaskApiHandlerIfNeeded"].bind(tab)) + tab["updateTaskApiHandlerIfNeeded"] = rebuild + const sticky = vi.fn(tab["persistStickyProviderProfileToCurrentTask"].bind(tab)) + tab["persistStickyProviderProfileToCurrentTask"] = sticky + const active = expect( + tab.activateProviderProfile({ name: "closed" }, { skipCurrentTaskRebuild: true }), + ).rejects.toThrow("Provider disposed") + await vi.waitFor(() => expect(select).toHaveBeenCalledOnce()) + const queued = expect( + tab.activateProviderProfile({ name: "closed" }, { skipCurrentTaskRebuild: true }), + ).rejects.toThrow("Provider disposed") + await tab.dispose() + await Promise.all([active, queued]) + reopened = makeTab() + vi.spyOn(reopened.providerSettingsManager, "activateProfile").mockResolvedValue({ + name: "reopened", + id: "reopened-id", + apiProvider: providerIdentifiers.anthropic, + }) + const fresh = reopened.activateProviderProfile({ name: "reopened" }, { skipCurrentTaskRebuild: true }) + release() + await Promise.all([first, fresh]) + + expect(activate).toHaveBeenCalledOnce() + expect(write).not.toHaveBeenCalled() + expect(rebuild).not.toHaveBeenCalled() + expect(sticky).not.toHaveBeenCalled() + await expect(manager.getModeConfigId("code")).resolves.toBe("reopened-id") + await expect(reopened["getModeConfigId"]("code")).resolves.toBe("reopened-id") + } finally { + release() + await tab.dispose() + await reopened?.dispose() + } + }) + it.each(["snapshot", "profiles"])("stops a cancelled mode switch during %s lookup", async (stage) => { let release = () => {} const pending = new Promise((resolve) => { @@ -4932,7 +5048,12 @@ describe("ClineProvider", () => { await provider["setModeConfig"]("code", "this-window-id") - expect(manager.setModeConfig).toHaveBeenCalledWith("code", "this-window-id", expect.any(Function)) + expect(manager.setModeConfig).toHaveBeenCalledWith( + "code", + "this-window-id", + expect.any(Function), + expect.any(AbortSignal), + ) await expect(provider["getModeConfigId"]("code")).resolves.toBe("this-window-id") }) @@ -5090,7 +5211,12 @@ describe("ClineProvider", () => { rejectWrite(new Error("write failed")) await failure await succeeded - expect(sharedWrite).toHaveBeenLastCalledWith("code", nextId, expect.any(Function)) + expect(sharedWrite).toHaveBeenLastCalledWith( + "code", + nextId, + expect.any(Function), + expect.any(AbortSignal), + ) await expect(provider["getModeConfigId"]("code")).resolves.toBe(nextId) }, ) @@ -5118,13 +5244,13 @@ describe("ClineProvider", () => { }) const first = provider.setModeConfig("code", "first-id") await vi.waitFor(() => expect(store).toHaveBeenCalledOnce()) - const second = provider.setModeConfig("code", "second-id") + const second = expect(provider.setModeConfig("code", "second-id")).rejects.toThrow("settings reset") const resetConfigs = vi.spyOn(manager, "resetAllConfigs") const resetting = provider.resetState() await vi.waitFor(() => expect(provider["modeProfileState"].reset).toBeDefined()) // Deletion waits for the active write; another selection during reset must also be ignored. expect(resetConfigs).not.toHaveBeenCalled() - await provider.setModeConfig("code", "second-id") + await expect(provider.setModeConfig("code", "second-id")).rejects.toThrow("settings reset") release() await Promise.all([first, second, resetting]) @@ -5252,7 +5378,10 @@ describe("ClineProvider", () => { ) // Ensure the `activateProfile` method was called with the correct ID - expect(provider.providerSettingsManager.activateProfile).toHaveBeenCalledWith({ id: "config-id-123" }) + expect(provider.providerSettingsManager.activateProfile).toHaveBeenCalledWith( + { id: "config-id-123" }, + expect.any(AbortSignal), + ) }) test("handles showRooIgnoredFiles setting", async () => { @@ -5783,7 +5912,10 @@ describe("ClineProvider", () => { // Verify saved config was loaded expect(provider.providerSettingsManager.getModeConfigId).not.toHaveBeenCalled() - expect(provider.providerSettingsManager.activateProfile).toHaveBeenCalledWith({ name: "saved-config" }) + expect(provider.providerSettingsManager.activateProfile).toHaveBeenCalledWith( + { name: "saved-config" }, + expect.any(AbortSignal), + ) expect(mockContext.globalState.update).toHaveBeenCalledWith("currentApiConfigName", "saved-config") // Verify state was posted to webview diff --git a/src/core/webview/__tests__/ClineProvider.sticky-mode.spec.ts b/src/core/webview/__tests__/ClineProvider.sticky-mode.spec.ts index 0d54c1464c..6e6a2c5b51 100644 --- a/src/core/webview/__tests__/ClineProvider.sticky-mode.spec.ts +++ b/src/core/webview/__tests__/ClineProvider.sticky-mode.spec.ts @@ -777,7 +777,7 @@ describe("ClineProvider - Sticky Mode", () => { // Restore the task from history await provider.createTaskWithHistoryItem(historyItem) - expect(activate).toHaveBeenCalledWith({ name: "architect-config" }) + expect(activate).toHaveBeenCalledWith({ name: "architect-config" }, expect.any(AbortSignal)) await expect(provider.providerSettingsManager.getModeConfigId("architect")).resolves.toBe(codeConfigId) // Verify that the mode was restored diff --git a/src/extension/__tests__/api-configuration.spec.ts b/src/extension/__tests__/api-configuration.spec.ts index 6e1e4f0885..944f1af00d 100644 --- a/src/extension/__tests__/api-configuration.spec.ts +++ b/src/extension/__tests__/api-configuration.spec.ts @@ -27,6 +27,7 @@ describe("API - configuration", () => { { name: "custom", id: "architect-config" }, ]), }, + profileMutationAbortController: new AbortController(), modeProfileState: { reset: undefined }, localModeConfigIds: new Map(), modeConfigWriteOwners: new Map(), @@ -54,13 +55,64 @@ describe("API - configuration", () => { }), ) expect(setModeConfig).toHaveBeenCalledTimes(2) - expect(setModeConfig).toHaveBeenCalledWith("code", "code-config", expect.any(Function)) - expect(setModeConfig).toHaveBeenCalledWith("new-custom-mode", "architect-config", expect.any(Function)) + expect(setModeConfig).toHaveBeenCalledWith("code", "code-config", expect.any(Function), expect.any(AbortSignal)) + expect(setModeConfig).toHaveBeenCalledWith( + "new-custom-mode", + "architect-config", + expect.any(Function), + expect.any(AbortSignal), + ) await expect(provider["getModeConfigId"]("code")).resolves.toBe("code-config") await expect(provider["getModeConfigId"]("new-custom-mode")).resolves.toBe("architect-config") expect(postStateToWebview).toHaveBeenCalledOnce() }) + it("reports partial persistence after all mode writes settle when reset cancels a mapping", async () => { + const setValues = vi.fn().mockResolvedValue(undefined) + const saveConfig = vi.fn().mockResolvedValue("default-id") + let release = () => {} + const pending = new Promise((resolve) => { + release = resolve + }) + const setModeConfig = vi + .fn() + .mockRejectedValueOnce(new Error("Mode profile write cancelled by settings reset")) + .mockImplementationOnce(async () => { + await pending + }) + const postStateToWebview = vi.fn().mockResolvedValue(undefined) + // Supplies configuration persistence, profile storage, and the event hook used by API. + const provider = { + context: {}, + on: vi.fn(), + contextProxy: { setValues }, + providerSettingsManager: { saveConfig }, + setModeConfig, + postStateToWebview, + } as unknown as ClineProvider + // API only appends log lines to this output double. + const outputChannel = { appendLine: vi.fn() } as unknown as vscode.OutputChannel + const api = new API(outputChannel, provider, makeClineProviderFactory()) + const outcomes: string[] = [] + const updated = api + .setConfiguration({ + currentApiConfigName: "default", + modeApiConfigs: { code: "code-id", architect: "architect-id" }, + }) + .finally(() => { + outcomes.push("settled") + }) + const failed = expect(updated).rejects.toThrow("Configuration update may be partially persisted") + await vi.waitFor(() => expect(setModeConfig).toHaveBeenCalledTimes(2)) + expect(setValues).toHaveBeenCalledOnce() + expect(saveConfig).toHaveBeenCalledOnce() + expect(outcomes).toEqual([]) + release() + await failed + + expect(postStateToWebview).not.toHaveBeenCalled() + }) + it("does not persist mode mappings when none are supplied", async () => { const setValues = vi.fn().mockResolvedValue(undefined) const saveConfig = vi.fn().mockResolvedValue("default-id") diff --git a/src/extension/api.ts b/src/extension/api.ts index 60110919a7..73265c8ff5 100644 --- a/src/extension/api.ts +++ b/src/extension/api.ts @@ -632,11 +632,20 @@ export class API extends EventEmitter implements RooCodeAPI { await this.sidebarProvider.contextProxy.setValues(values) await this.sidebarProvider.providerSettingsManager.saveConfig(values.currentApiConfigName || "default", values) if (values.modeApiConfigs) { - await Promise.all( + const results = await Promise.allSettled( Object.entries(values.modeApiConfigs).map(([mode, configId]) => this.sidebarProvider.setModeConfig(mode as Mode, configId), ), ) + const failed = results.find((result): result is PromiseRejectedResult => result.status === "rejected") + if (failed) { + throw new Error( + "Configuration update may be partially persisted: mode profile mappings were not fully saved", + { + cause: failed.reason, + }, + ) + } } await this.sidebarProvider.postStateToWebview() } From c13f0cee8bbd9862e18fc39616f9e0ee46b7be2a Mon Sep 17 00:00:00 2001 From: Elliott de Launay Date: Wed, 11 Nov 2026 04:00:24 +0000 Subject: [PATCH 16/30] test: assert precise mode profile cancellation errors --- .../__tests__/ProviderSettingsManager.spec.ts | 16 +++++++++++++--- src/core/webview/__tests__/ClineProvider.spec.ts | 12 ++++++++++-- 2 files changed, 23 insertions(+), 5 deletions(-) diff --git a/src/core/config/__tests__/ProviderSettingsManager.spec.ts b/src/core/config/__tests__/ProviderSettingsManager.spec.ts index ac5eef271c..aab9d46380 100644 --- a/src/core/config/__tests__/ProviderSettingsManager.spec.ts +++ b/src/core/config/__tests__/ProviderSettingsManager.spec.ts @@ -140,7 +140,12 @@ describe("ProviderSettingsManager", () => { const selected = providerSettingsManager.setModeConfig("code", "selected-id", published, controller.signal) if (cancel) controller.abort() release() - const result = cancel ? expect(selected).rejects.toThrow("aborted") : expect(selected).resolves.toBeUndefined() + const result = cancel + ? expect(selected).rejects.toMatchObject({ + name: "Error", + message: "Failed to set mode config: AbortError: This operation was aborted", + }) + : expect(selected).resolves.toBeUndefined() await Promise.all([imported, result]) expect(mockSecrets.get).toHaveBeenCalledTimes(cancel ? 0 : 1) @@ -162,7 +167,12 @@ describe("ProviderSettingsManager", () => { const selected = providerSettingsManager.setModeConfig("code", "selected-id", published, controller.signal) await vi.waitFor(() => expect(mockSecrets.get).toHaveBeenCalledOnce()) if (cancel) controller.abort() - const result = cancel ? expect(selected).rejects.toThrow("aborted") : expect(selected).resolves.toBeUndefined() + const result = cancel + ? expect(selected).rejects.toMatchObject({ + name: "Error", + message: "Failed to set mode config: AbortError: This operation was aborted", + }) + : expect(selected).resolves.toBeUndefined() release() await result @@ -189,7 +199,7 @@ describe("ProviderSettingsManager", () => { const selected = providerSettingsManager.activateProfile({ name: "selected" }, controller.signal) if (cancel) controller.abort() const result = cancel - ? expect(selected).rejects.toThrow("aborted") + ? expect(selected).rejects.toMatchObject({ name: "AbortError", message: "This operation was aborted" }) : expect(selected).resolves.toMatchObject({ name: "selected", id: "selected-id" }) release() await Promise.all([imported, result]) diff --git a/src/core/webview/__tests__/ClineProvider.spec.ts b/src/core/webview/__tests__/ClineProvider.spec.ts index 59019b86b1..f9fc16b205 100644 --- a/src/core/webview/__tests__/ClineProvider.spec.ts +++ b/src/core/webview/__tests__/ClineProvider.spec.ts @@ -4732,7 +4732,12 @@ describe("ClineProvider", () => { expect(provider["localModeConfigIds"].get("code")).toBe("selected-id") if (cancel) controller.abort() release() - const result = cancel ? expect(write).rejects.toThrow("aborted") : expect(write).resolves.toBeUndefined() + const result = cancel + ? expect(write).rejects.toMatchObject({ + name: "Error", + message: "Failed to set mode config: AbortError: This operation was aborted", + }) + : expect(write).resolves.toBeUndefined() await Promise.all([imported, result]) await expect(manager.getModeConfigId("code")).resolves.toBe(cancel ? "imported-id" : "selected-id") @@ -4776,7 +4781,10 @@ describe("ClineProvider", () => { release() const result = stage === "queued" - ? expect(activation).rejects.toThrow("aborted") + ? expect(activation).rejects.toMatchObject({ + name: "AbortError", + message: "This operation was aborted", + }) : expect(activation).resolves.toBeUndefined() await Promise.all([preceding, result]) From dc84dad36e72a1c0cd744b302d284256c0e26e87 Mon Sep 17 00:00:00 2001 From: Elliott de Launay Date: Wed, 11 Nov 2026 04:01:21 +0000 Subject: [PATCH 17/30] test: expect cancellation signal in mode profile activation --- src/core/webview/__tests__/ClineProvider.lockApiConfig.spec.ts | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/core/webview/__tests__/ClineProvider.lockApiConfig.spec.ts b/src/core/webview/__tests__/ClineProvider.lockApiConfig.spec.ts index 7c85e90e76..6fd5ea2b40 100644 --- a/src/core/webview/__tests__/ClineProvider.lockApiConfig.spec.ts +++ b/src/core/webview/__tests__/ClineProvider.lockApiConfig.spec.ts @@ -396,7 +396,7 @@ describe("ClineProvider - Lock API Config Across Modes", () => { await provider.handleModeSwitch("architect") expect(getModeConfigIdSpy).not.toHaveBeenCalled() - expect(activateProfileSpy).toHaveBeenCalledWith({ name: "architect-profile" }) + expect(activateProfileSpy).toHaveBeenCalledWith({ name: "architect-profile" }, expect.any(AbortSignal)) }) }) }) From 56e0506552a5d16d516036001f532887d7accc5e Mon Sep 17 00:00:00 2001 From: Elliott de Launay Date: Wed, 11 Nov 2026 04:29:24 +0000 Subject: [PATCH 18/30] fix: coordinate profile mutations with settings reset --- .../__tests__/ProviderSettingsManager.spec.ts | 45 ++++++++++++- src/core/webview/ClineProvider.ts | 36 +++++++--- .../webview/__tests__/ClineProvider.spec.ts | 66 +++++++++++++++++++ .../__tests__/api-configuration.spec.ts | 2 +- 4 files changed, 137 insertions(+), 12 deletions(-) diff --git a/src/core/config/__tests__/ProviderSettingsManager.spec.ts b/src/core/config/__tests__/ProviderSettingsManager.spec.ts index aab9d46380..79cef73e37 100644 --- a/src/core/config/__tests__/ProviderSettingsManager.spec.ts +++ b/src/core/config/__tests__/ProviderSettingsManager.spec.ts @@ -154,6 +154,9 @@ describe("ProviderSettingsManager", () => { }) it.each([false, true])("checks cancellation after loading profiles (cancelled: %s)", async (cancel) => { + // Drain constructor initialization so the delayed read belongs to this operation. + await providerSettingsManager.getModeConfigIds() + mockSecrets.get.mockClear() let release = () => {} const pending = new Promise((resolve) => { release = resolve @@ -194,19 +197,57 @@ describe("ProviderSettingsManager", () => { modeApiConfigs: {}, }) await vi.waitFor(() => expect(mockSecrets.store).toHaveBeenCalledOnce()) - vi.spyOn(providerSettingsManager, "getProfile").mockResolvedValue({ name: "selected", id: "selected-id" }) + mockSecrets.get.mockClear() + const profile = vi + .spyOn(providerSettingsManager, "getProfile") + .mockResolvedValue({ name: "selected", id: "selected-id" }) const controller = new AbortController() const selected = providerSettingsManager.activateProfile({ name: "selected" }, controller.signal) + // Resume past getProfile while the import still holds the storage lock. + await profile.mock.results[0].value if (cancel) controller.abort() const result = cancel - ? expect(selected).rejects.toMatchObject({ name: "AbortError", message: "This operation was aborted" }) + ? expect(selected).rejects.toMatchObject({ + name: "Error", + message: "Failed to activate profile: This operation was aborted", + }) : expect(selected).resolves.toMatchObject({ name: "selected", id: "selected-id" }) release() await Promise.all([imported, result]) + expect(mockSecrets.get).toHaveBeenCalledTimes(cancel ? 0 : 1) expect(mockSecrets.store).toHaveBeenCalledTimes(cancel ? 1 : 2) }) + it.each([false, true])("cancels activation during the locked profile load (cancelled: %s)", async (cancel) => { + // Drain constructor initialization so the delayed read belongs to this operation. + await providerSettingsManager.getModeConfigIds() + mockSecrets.get.mockClear() + vi.spyOn(providerSettingsManager, "getProfile").mockResolvedValue({ name: "selected", id: "selected-id" }) + let release = () => {} + const pending = new Promise((resolve) => { + release = resolve + }) + mockSecrets.get.mockImplementationOnce(async () => { + await pending + return null + }) + const controller = new AbortController() + const selected = providerSettingsManager.activateProfile({ name: "selected" }, controller.signal) + await vi.waitFor(() => expect(mockSecrets.get).toHaveBeenCalledOnce()) + if (cancel) controller.abort() + const result = cancel + ? expect(selected).rejects.toMatchObject({ + name: "Error", + message: "Failed to activate profile: This operation was aborted", + }) + : expect(selected).resolves.toMatchObject({ name: "selected", id: "selected-id" }) + release() + await result + + expect(mockSecrets.store).toHaveBeenCalledTimes(cancel ? 0 : 1) + }) + describe("initialize", () => { it("should not write to storage when secrets.get returns null", async () => { // Mock readConfig to return null diff --git a/src/core/webview/ClineProvider.ts b/src/core/webview/ClineProvider.ts index ae69d7a546..8385850075 100644 --- a/src/core/webview/ClineProvider.ts +++ b/src/core/webview/ClineProvider.ts @@ -345,14 +345,24 @@ export class ClineProvider fn: (signal: AbortSignal) => Promise, options: { runToCompletion?: boolean } = {}, ): Promise { + if (this.modeProfileState.reset) { + return Promise.reject(new Error("Provider profile mutation cancelled by settings reset")) + } const controller = new AbortController() const signal = AbortSignal.any([controller.signal, this.profileMutationAbortController.signal]) - const invoke = () => { + const invoke = async () => { signal.throwIfAborted() - return fn(signal) + if (this.modeProfileState.reset) throw new Error("Provider profile mutation cancelled by settings reset") + this.modeProfileState.activeMutationSignals.add(signal) + try { + return await fn(signal) + } finally { + this.modeProfileState.activeMutationSignals.delete(signal) + } } // Run fn after either outcome so a rejected mutation never poisons the queue. const run = this.providerProfileMutationQueue.then(invoke, invoke) + this.modeProfileState.mutations.add(run) const callerResult = this.withProviderProfileMutationTimeout( run, () => { @@ -369,11 +379,13 @@ export class ClineProvider void run.then( () => { + this.modeProfileState.mutations.delete(run) if (controller.signal.aborted) { this.log("Provider profile mutation completed after cancellation") } }, (error) => { + this.modeProfileState.mutations.delete(run) if (controller.signal.aborted) { this.log( `Provider profile mutation errored after cancellation: ${ @@ -448,6 +460,8 @@ export class ClineProvider localIds: new Map(), writeOwners: new Map(), writes: new Map>(), + mutations: new Set>(), + activeMutationSignals: new Set(), reset: undefined as Promise | undefined, // Capture the shared map once when the window opens; late tabs reuse that snapshot. // Undefined means the opening snapshot failed, rather than an empty mapping. @@ -2246,18 +2260,22 @@ export class ClineProvider } public async setModeConfig(mode: Mode, id: string, signal?: AbortSignal): Promise { + // An activation that reset is draining must finish all its writes before deletion. + const completingMutation = signal !== undefined && this.modeProfileState.activeMutationSignals.has(signal) const writeSignal = signal ? AbortSignal.any([signal, this.profileMutationAbortController.signal]) : this.profileMutationAbortController.signal writeSignal.throwIfAborted() - if (this.modeProfileState.reset) throw new Error("Mode profile write cancelled by settings reset") + if (this.modeProfileState.reset && !completingMutation) + throw new Error("Mode profile write cancelled by settings reset") const pending = this.modeConfigWrites.get(mode) const write = (async () => { // A failed predecessor must roll back before this operation captures its previous choice. if (pending) await pending.catch(() => {}) // Reset invalidates queued selections before their profiles are deleted. writeSignal.throwIfAborted() - if (this.modeProfileState.reset) throw new Error("Mode profile write cancelled by settings reset") + if (this.modeProfileState.reset && !completingMutation) + throw new Error("Mode profile write cancelled by settings reset") await this.writeModeConfig(mode, id, writeSignal) })() this.modeConfigWrites.set(mode, write) @@ -3884,7 +3902,7 @@ export class ClineProvider } if (this.modeProfileState.reset) return this.modeProfileState.reset - const reset = this.resetStateAfterModeWrites() + const reset = this.resetStateAfterProfileMutations() this.modeProfileState.reset = reset try { await reset @@ -3893,10 +3911,10 @@ export class ClineProvider } } - private async resetStateAfterModeWrites(): Promise { - // Finish active writes and cancel queued ones before deleting their persisted mappings. - // The shared reset promise also blocks new selections in other tabs until reset finishes. - await Promise.allSettled([...this.modeConfigWrites.values()]) + private async resetStateAfterProfileMutations(): Promise { + // Drain whole profile mutations, including saves and context updates, before deleting state. + // The shared reset promise rejects new/queued mutations in every tab while active ones finish. + await Promise.allSettled([...this.modeProfileState.mutations, ...this.modeConfigWrites.values()]) // Log out from cloud if authenticated if (CloudService.hasInstance()) { diff --git a/src/core/webview/__tests__/ClineProvider.spec.ts b/src/core/webview/__tests__/ClineProvider.spec.ts index f9fc16b205..6fd05dbef3 100644 --- a/src/core/webview/__tests__/ClineProvider.spec.ts +++ b/src/core/webview/__tests__/ClineProvider.spec.ts @@ -5229,6 +5229,72 @@ describe("ClineProvider", () => { }, ) + it.each(["activation", "profile save"])( + "drains an active %s before resetting and rejects later mutations", + async (operation) => { + const { t } = await import("../../../i18n") + await provider.setValue("mode", "code") + vi.mocked(vscode.window.showInformationMessage).mockResolvedValueOnce(t("common:answers.yes") as never) + vi.spyOn(provider, "postStateToWebview").mockResolvedValue(undefined) + vi.spyOn(provider, "postMessageToWebview").mockResolvedValue(undefined) + provider.customModesManager.resetCustomModes = vi.fn().mockResolvedValue(undefined) + const manager = provider.providerSettingsManager + await manager.import({ + currentApiConfigName: "opened", + apiConfigs: { + opened: { id: "opened-id", apiProvider: providerIdentifiers.anthropic }, + selected: { id: "selected-id", apiProvider: providerIdentifiers.anthropic }, + }, + modeApiConfigs: {}, + }) + let release = () => {} + const pending = new Promise((resolve) => { + release = resolve + }) + const originalActivate = manager.activateProfile.bind(manager) + const originalSave = manager.saveConfig.bind(manager) + const activate = vi.spyOn(manager, "activateProfile") + const save = vi.spyOn(manager, "saveConfig") + if (operation === "activation") { + activate.mockImplementationOnce(async (...args) => { + await pending + return originalActivate(...args) + }) + } else { + save.mockImplementationOnce(async (...args) => { + await pending + return originalSave(...args) + }) + } + const active = + operation === "activation" + ? provider.activateProviderProfile({ name: "selected" }) + : provider.upsertProviderProfile("selected", { apiProvider: providerIdentifiers.anthropic }) + await vi.waitFor(() => expect(operation === "activation" ? activate : save).toHaveBeenCalledOnce()) + const queued = expect(provider.activateProviderProfile({ name: "opened" })).rejects.toThrow( + "settings reset", + ) + const resetConfigs = vi.spyOn(manager, "resetAllConfigs") + const resetContext = vi.spyOn(provider.contextProxy, "resetAllState") + const resetting = provider.resetState() + await vi.waitFor(() => expect(provider["modeProfileState"].reset).toBeDefined()) + expect(resetConfigs).not.toHaveBeenCalled() + expect(resetContext).not.toHaveBeenCalled() + await expect(provider.activateProviderProfile({ name: "opened" })).rejects.toThrow("settings reset") + release() + const result = await active + if (operation === "profile save") expect(result).toBe("selected-id") + await Promise.all([queued, resetting]) + + expect(resetConfigs).toHaveBeenCalledOnce() + expect(await mockContext.secrets.get(manager["secretsKey"])).toBeUndefined() + expect(provider["localModeConfigIds"].size).toBe(0) + expect(provider["modeProfileState"].mutations.size).toBe(0) + expect(activate).toHaveBeenCalledTimes(operation === "activation" ? 1 : 0) + expect(save).toHaveBeenCalledTimes(operation === "profile save" ? 1 : 0) + }, + ) + it("does not restore stale mode mappings when reset overlaps two queued same-mode writes", async () => { const { t } = await import("../../../i18n") vi.mocked(vscode.window.showInformationMessage).mockResolvedValueOnce(t("common:answers.yes") as never) diff --git a/src/extension/__tests__/api-configuration.spec.ts b/src/extension/__tests__/api-configuration.spec.ts index 944f1af00d..6106b95fe9 100644 --- a/src/extension/__tests__/api-configuration.spec.ts +++ b/src/extension/__tests__/api-configuration.spec.ts @@ -28,7 +28,7 @@ describe("API - configuration", () => { ]), }, profileMutationAbortController: new AbortController(), - modeProfileState: { reset: undefined }, + modeProfileState: { reset: undefined, activeMutationSignals: new Set() }, localModeConfigIds: new Map(), modeConfigWriteOwners: new Map(), modeConfigWrites: new Map>(), From 6c268cd8f0c755f84f043ea4a87c923dd11009e7 Mon Sep 17 00:00:00 2001 From: Elliott de Launay Date: Wed, 11 Nov 2026 05:05:34 +0000 Subject: [PATCH 19/30] fix: finish committed profile persistence after disposal --- src/core/config/ProviderSettingsManager.ts | 2 + .../__tests__/ProviderSettingsManager.spec.ts | 29 ++- src/core/webview/ClineProvider.ts | 170 +++++++++++------- .../ClineProvider.apiHandlerRebuild.spec.ts | 11 +- .../ClineProvider.lockApiConfig.spec.ts | 6 +- .../webview/__tests__/ClineProvider.spec.ts | 115 ++++++------ .../ClineProvider.sticky-mode.spec.ts | 6 +- .../__tests__/api-configuration.spec.ts | 6 +- 8 files changed, 219 insertions(+), 126 deletions(-) diff --git a/src/core/config/ProviderSettingsManager.ts b/src/core/config/ProviderSettingsManager.ts index e382c4a827..61893b3f9a 100644 --- a/src/core/config/ProviderSettingsManager.ts +++ b/src/core/config/ProviderSettingsManager.ts @@ -488,6 +488,7 @@ export class ProviderSettingsManager { public async activateProfile( params: { name: string } | { id: string }, signal?: AbortSignal, + onPersisting?: () => void, ): Promise { signal?.throwIfAborted() const { name, ...providerSettings } = await this.getProfile(params) @@ -499,6 +500,7 @@ export class ProviderSettingsManager { const providerProfiles = await this.load() signal?.throwIfAborted() providerProfiles.currentApiConfigName = name + onPersisting?.() await this.store(providerProfiles) return { name, ...providerSettings } }) diff --git a/src/core/config/__tests__/ProviderSettingsManager.spec.ts b/src/core/config/__tests__/ProviderSettingsManager.spec.ts index 79cef73e37..875cdfeb1c 100644 --- a/src/core/config/__tests__/ProviderSettingsManager.spec.ts +++ b/src/core/config/__tests__/ProviderSettingsManager.spec.ts @@ -202,7 +202,8 @@ describe("ProviderSettingsManager", () => { .spyOn(providerSettingsManager, "getProfile") .mockResolvedValue({ name: "selected", id: "selected-id" }) const controller = new AbortController() - const selected = providerSettingsManager.activateProfile({ name: "selected" }, controller.signal) + const onPersisting = vi.fn() + const selected = providerSettingsManager.activateProfile({ name: "selected" }, controller.signal, onPersisting) // Resume past getProfile while the import still holds the storage lock. await profile.mock.results[0].value if (cancel) controller.abort() @@ -217,6 +218,7 @@ describe("ProviderSettingsManager", () => { expect(mockSecrets.get).toHaveBeenCalledTimes(cancel ? 0 : 1) expect(mockSecrets.store).toHaveBeenCalledTimes(cancel ? 1 : 2) + expect(onPersisting).toHaveBeenCalledTimes(cancel ? 0 : 1) }) it.each([false, true])("cancels activation during the locked profile load (cancelled: %s)", async (cancel) => { @@ -233,7 +235,8 @@ describe("ProviderSettingsManager", () => { return null }) const controller = new AbortController() - const selected = providerSettingsManager.activateProfile({ name: "selected" }, controller.signal) + const onPersisting = vi.fn() + const selected = providerSettingsManager.activateProfile({ name: "selected" }, controller.signal, onPersisting) await vi.waitFor(() => expect(mockSecrets.get).toHaveBeenCalledOnce()) if (cancel) controller.abort() const result = cancel @@ -246,6 +249,28 @@ describe("ProviderSettingsManager", () => { await result expect(mockSecrets.store).toHaveBeenCalledTimes(cancel ? 0 : 1) + expect(onPersisting).toHaveBeenCalledTimes(cancel ? 0 : 1) + }) + + it("announces the activation commit boundary before an uninterruptible storage write", async () => { + await providerSettingsManager.getModeConfigIds() + vi.spyOn(providerSettingsManager, "getProfile").mockResolvedValue({ name: "selected", id: "selected-id" }) + let release = () => {} + const pending = new Promise((resolve) => { + release = resolve + }) + mockSecrets.store.mockImplementationOnce(async () => { + await pending + }) + const controller = new AbortController() + const onPersisting = vi.fn() + const selected = providerSettingsManager.activateProfile({ name: "selected" }, controller.signal, onPersisting) + await vi.waitFor(() => expect(mockSecrets.store).toHaveBeenCalledOnce()) + expect(onPersisting).toHaveBeenCalledOnce() + controller.abort() + release() + + await expect(selected).resolves.toMatchObject({ name: "selected", id: "selected-id" }) }) describe("initialize", () => { diff --git a/src/core/webview/ClineProvider.ts b/src/core/webview/ClineProvider.ts index 8385850075..a2bdd8dd0a 100644 --- a/src/core/webview/ClineProvider.ts +++ b/src/core/webview/ClineProvider.ts @@ -329,7 +329,13 @@ export class ClineProvider private taskHistoryStoreInitialized = false public static readonly PENDING_OPERATION_TIMEOUT_MS = 30000 // 30 seconds private readonly profileMutationAbortController = new AbortController() - private providerProfileMutationQueue = Promise.resolve() + private get providerProfileMutationQueue() { + return this.modeProfileState.profileMutationQueue + } + + private set providerProfileMutationQueue(queue: Promise) { + this.modeProfileState.profileMutationQueue = queue + } private historyTaskCreationQueue = Promise.resolve() private runDelegationTransition(parentTaskId: string, fn: () => Promise): Promise { @@ -361,12 +367,13 @@ export class ClineProvider } } // Run fn after either outcome so a rejected mutation never poisons the queue. - const run = this.providerProfileMutationQueue.then(invoke, invoke) + const previous = this.providerProfileMutationQueue + const run = previous.then(invoke, invoke) this.modeProfileState.mutations.add(run) const callerResult = this.withProviderProfileMutationTimeout( run, () => { - if (options.runToCompletion) { + if (options.runToCompletion || this.modeProfileState.committingMutationSignals.has(signal)) { this.log("Provider profile mutation timed out; waiting for it to finish before the next mutation") return } @@ -375,18 +382,21 @@ export class ClineProvider this.log("Provider profile mutation timed out; aborting in-flight mutation") }, this.profileMutationAbortController.signal, + signal, ) void run.then( () => { this.modeProfileState.mutations.delete(run) - if (controller.signal.aborted) { + this.modeProfileState.committingMutationSignals.delete(signal) + if (signal.aborted) { this.log("Provider profile mutation completed after cancellation") } }, (error) => { this.modeProfileState.mutations.delete(run) - if (controller.signal.aborted) { + this.modeProfileState.committingMutationSignals.delete(signal) + if (signal.aborted) { this.log( `Provider profile mutation errored after cancellation: ${ error instanceof Error ? error.message : String(error) @@ -396,11 +406,17 @@ export class ClineProvider }, ) - // Advance from the timeout-bounded result. Each fn checks its AbortSignal before - // writing state, so advancing the queue on timeout cannot produce stale overwrites. - this.providerProfileMutationQueue = (options.runToCompletion ? run : callerResult).then( - () => undefined, + // A cancelled read may release the queue, but a started commit must finish before any tab writes again. + this.providerProfileMutationQueue = callerResult.then( () => undefined, + async () => { + if (options.runToCompletion || this.modeProfileState.committingMutationSignals.has(signal)) { + await run.catch(() => {}) + } else { + // Cancelling a queued item must not bypass an earlier committing mutation. + await previous.catch(() => {}) + } + }, ) return callerResult } @@ -409,6 +425,7 @@ export class ClineProvider operation: Promise, onTimeout: () => void, signal: AbortSignal, + mutationSignal: AbortSignal, ): Promise { let timeoutId: ReturnType | undefined const timeout = new Promise((_, reject) => { @@ -419,7 +436,9 @@ export class ClineProvider }) let onAbort = () => {} const cancelled = new Promise((_, reject) => { - onAbort = () => reject(signal.reason) + onAbort = () => { + if (!this.modeProfileState.committingMutationSignals.has(mutationSignal)) reject(signal.reason) + } if (signal.aborted) onAbort() else signal.addEventListener("abort", onAbort, { once: true }) }) @@ -461,7 +480,9 @@ export class ClineProvider writeOwners: new Map(), writes: new Map>(), mutations: new Set>(), + profileMutationQueue: Promise.resolve(), activeMutationSignals: new Set(), + committingMutationSignals: new Set(), reset: undefined as Promise | undefined, // Capture the shared map once when the window opens; late tabs reuse that snapshot. // Undefined means the opening snapshot failed, rather than an empty mapping. @@ -2261,10 +2282,14 @@ export class ClineProvider public async setModeConfig(mode: Mode, id: string, signal?: AbortSignal): Promise { // An activation that reset is draining must finish all its writes before deletion. - const completingMutation = signal !== undefined && this.modeProfileState.activeMutationSignals.has(signal) - const writeSignal = signal - ? AbortSignal.any([signal, this.profileMutationAbortController.signal]) - : this.profileMutationAbortController.signal + const committing = signal !== undefined && this.modeProfileState.committingMutationSignals.has(signal) + const completingMutation = + committing || (signal !== undefined && this.modeProfileState.activeMutationSignals.has(signal)) + const writeSignal = committing + ? new AbortController().signal + : signal + ? AbortSignal.any([signal, this.profileMutationAbortController.signal]) + : this.profileMutationAbortController.signal writeSignal.throwIfAborted() if (this.modeProfileState.reset && !completingMutation) throw new Error("Mode profile write cancelled by settings reset") @@ -2498,15 +2523,14 @@ export class ClineProvider // we rely on the `ContextProxy`'s data store and in other cases // we rely on the `ProviderSettingsManager`'s data store. It might // be simpler to unify these two. + if (activate) this.modeProfileState.committingMutationSignals.add(signal) const id = await this.providerSettingsManager.saveConfig(name, providerSettings) - if (signal.aborted) return id + if (signal.aborted && !activate) return id if (activate) { const { mode } = await this.getState() - if (signal.aborted) return id - // These promises do the following: // 1. Adds or updates the list of provider profiles. // 2. Sets the current provider profile. @@ -2519,7 +2543,6 @@ export class ClineProvider // I left the original implementation in just to be safe. // `allSettled` so a caller that rolls back after a failure never races a write still in flight. const profiles = await this.providerSettingsManager.listConfig() - signal.throwIfAborted() const activationResults = await Promise.allSettled([ this.updateGlobalState("listApiConfigMeta", profiles), this.updateGlobalState("currentApiConfigName", name), @@ -2626,63 +2649,74 @@ export class ClineProvider skipCurrentTaskRebuild?: boolean expectedCurrentTaskId?: string }, - signal?: AbortSignal, + signal: AbortSignal = this.profileMutationAbortController.signal, ): Promise { - if (signal?.aborted) return - const { name, id, ...providerSettings } = signal - ? await this.providerSettingsManager.activateProfile(args, signal) - : await this.providerSettingsManager.activateProfile(args) - - if (signal?.aborted) return - - const persistModeConfig = options?.persistModeConfig ?? true - const persistTaskHistory = options?.persistTaskHistory ?? true - const skipCurrentTaskRebuild = options?.skipCurrentTaskRebuild ?? false - - if (!skipCurrentTaskRebuild) { - // See `upsertProviderProfile` for a description of what this is doing. - const profiles = await this.providerSettingsManager.listConfig() - signal?.throwIfAborted() - await Promise.all([ - this.contextProxy.setValue("listApiConfigMeta", profiles), - this.contextProxy.setValue("currentApiConfigName", name), - this.contextProxy.setProviderSettings(providerSettings), - ]) - } - - if (signal?.aborted) return - const { mode } = await this.getState() - - if (id && persistModeConfig) { - await this.setModeConfig(mode, id, signal) + signal.throwIfAborted() + const tracked = this.modeProfileState.activeMutationSignals.has(signal) + let persistenceStarted = false + let persistenceFinished = false + const startPersistence = () => { + persistenceStarted = true + this.modeProfileState.committingMutationSignals.add(signal) } - if (signal?.aborted) return + try { + const { name, id, ...providerSettings } = await this.providerSettingsManager.activateProfile( + args, + signal, + startPersistence, + ) + // Returning from activateProfile confirms that its active-profile write committed. + startPersistence() + const persistModeConfig = options?.persistModeConfig ?? true + const persistTaskHistory = options?.persistTaskHistory ?? true + const skipCurrentTaskRebuild = options?.skipCurrentTaskRebuild ?? false + + // Once the active profile write starts, finish its matching context and mode writes. + // Disposal still cancels queued activations and suppresses task/UI work below. + if (!skipCurrentTaskRebuild) { + const profiles = await this.providerSettingsManager.listConfig() + const writes = await Promise.allSettled([ + this.contextProxy.setValue("listApiConfigMeta", profiles), + this.contextProxy.setValue("currentApiConfigName", name), + this.contextProxy.setProviderSettings(providerSettings), + ]) + const failed = writes.find((result): result is PromiseRejectedResult => result.status === "rejected") + if (failed) throw failed.reason + } - // Change the provider for the current task. - const expectedCurrentTaskId = options?.expectedCurrentTaskId - this.updateTaskApiHandlerIfNeeded(providerSettings, { - forceRebuild: true, - skipCurrentTaskRebuild, - expectedCurrentTaskId, - }) + const { mode } = await this.getState() + if (id && persistModeConfig) await this.setModeConfig(mode, id, signal) + persistenceFinished = true + if (signal.aborted) return - // Update the current task's sticky provider profile, unless this activation is - // being used purely as a non-persisting restoration (e.g., reopening a task from history). - if (persistTaskHistory) { - await this.persistStickyProviderProfileToCurrentTask(name, { + const expectedCurrentTaskId = options?.expectedCurrentTaskId + this.updateTaskApiHandlerIfNeeded(providerSettings, { + forceRebuild: true, skipCurrentTaskRebuild, expectedCurrentTaskId, }) - } - - if (signal?.aborted) return - if (!skipCurrentTaskRebuild) { - await this.postStateToWebview() - } - - if (signal?.aborted) return - if (providerSettings.apiProvider && !skipCurrentTaskRebuild) { - this.emit(RooCodeEventName.ProviderProfileChanged, { name, provider: providerSettings.apiProvider }) + if (persistTaskHistory) { + await this.persistStickyProviderProfileToCurrentTask(name, { + skipCurrentTaskRebuild, + expectedCurrentTaskId, + }) + } + if (signal.aborted) return + if (!skipCurrentTaskRebuild) await this.postStateToWebview() + if (signal.aborted) return + if (providerSettings.apiProvider && !skipCurrentTaskRebuild) { + this.emit(RooCodeEventName.ProviderProfileChanged, { name, provider: providerSettings.apiProvider }) + } + } catch (error) { + if (persistenceStarted && !persistenceFinished) { + throw new Error( + `Profile activation may be partially persisted: ${error instanceof Error ? error.message : String(error)}`, + { cause: error }, + ) + } + throw error + } finally { + if (!tracked) this.modeProfileState.committingMutationSignals.delete(signal) } } diff --git a/src/core/webview/__tests__/ClineProvider.apiHandlerRebuild.spec.ts b/src/core/webview/__tests__/ClineProvider.apiHandlerRebuild.spec.ts index 0800092bde..395a872010 100644 --- a/src/core/webview/__tests__/ClineProvider.apiHandlerRebuild.spec.ts +++ b/src/core/webview/__tests__/ClineProvider.apiHandlerRebuild.spec.ts @@ -882,7 +882,7 @@ describe("ClineProvider - API Handler Rebuild Guard", () => { expect(setValueSpy).toHaveBeenCalledWith("currentApiConfigName", "second-profile") }) - test("timed-out mutations abort before writing state and advance the queue", async () => { + test("timed-out uncommitted mutations abort before writes and advance the queue", async () => { vi.useFakeTimers() const logSpy = vi.spyOn(provider, "log") const setValueSpy = vi.spyOn(provider.contextProxy, "setValue") @@ -892,8 +892,9 @@ describe("ClineProvider - API Handler Rebuild Guard", () => { }) provider["providerSettingsManager"].activateProfile = vi .fn() - .mockImplementationOnce(async () => { + .mockImplementationOnce(async (_args, signal) => { await firstActivation + signal?.throwIfAborted() return { name: "first-profile", id: "first-id", @@ -914,11 +915,14 @@ describe("ClineProvider - API Handler Rebuild Guard", () => { await vi.advanceTimersByTimeAsync(ClineProvider.PENDING_OPERATION_TIMEOUT_MS) await firstResult - // Queue advanced immediately on timeout — second enqueues now. + // An uncommitted timeout releases the queue while its cancelled storage read settles. const second = provider.activateProviderProfile({ name: "second-profile" }) // activateProfile not yet called for second (it runs in the next microtask). expect(provider["providerSettingsManager"].activateProfile).toHaveBeenCalledTimes(1) + await vi.advanceTimersByTimeAsync(0) + expect(provider["providerSettingsManager"].activateProfile).toHaveBeenCalledTimes(2) + // Resolve the first activation's inner promise so its in-flight mock can return. // The aborted signal prevents it from writing any state. resolveFirst() @@ -1014,6 +1018,7 @@ describe("ClineProvider - API Handler Rebuild Guard", () => { expect(provider["providerSettingsManager"].activateProfile).toHaveBeenCalledWith( { name: "ask-profile" }, expect.any(AbortSignal), + expect.any(Function), ) }) diff --git a/src/core/webview/__tests__/ClineProvider.lockApiConfig.spec.ts b/src/core/webview/__tests__/ClineProvider.lockApiConfig.spec.ts index 6fd5ea2b40..84c7760619 100644 --- a/src/core/webview/__tests__/ClineProvider.lockApiConfig.spec.ts +++ b/src/core/webview/__tests__/ClineProvider.lockApiConfig.spec.ts @@ -396,7 +396,11 @@ describe("ClineProvider - Lock API Config Across Modes", () => { await provider.handleModeSwitch("architect") expect(getModeConfigIdSpy).not.toHaveBeenCalled() - expect(activateProfileSpy).toHaveBeenCalledWith({ name: "architect-profile" }, expect.any(AbortSignal)) + expect(activateProfileSpy).toHaveBeenCalledWith( + { name: "architect-profile" }, + expect.any(AbortSignal), + expect.any(Function), + ) }) }) }) diff --git a/src/core/webview/__tests__/ClineProvider.spec.ts b/src/core/webview/__tests__/ClineProvider.spec.ts index 6fd05dbef3..945ebb8ce7 100644 --- a/src/core/webview/__tests__/ClineProvider.spec.ts +++ b/src/core/webview/__tests__/ClineProvider.spec.ts @@ -4486,6 +4486,7 @@ describe("ClineProvider", () => { expect(provider.providerSettingsManager.activateProfile).toHaveBeenCalledWith( { name: "test-config" }, expect.any(AbortSignal), + expect.any(Function), ) expect(mockContext.globalState.update).toHaveBeenCalledWith("currentApiConfigName", "test-config") }) @@ -4669,7 +4670,7 @@ describe("ClineProvider", () => { await provider["handleModeSwitchUnlocked"]("code", null) - expect(activate).toHaveBeenCalledWith({ name: "local" }) + expect(activate).toHaveBeenCalledWith({ name: "local" }, expect.any(AbortSignal), expect.any(Function)) expect(write).not.toHaveBeenCalled() await expect(manager.getModeConfigId("code")).resolves.toBe("other-id") await expect(provider["getModeConfigId"]("code")).resolves.toBe("local-id") @@ -4745,7 +4746,7 @@ describe("ClineProvider", () => { }) it.each(["queued", "persisting"])( - "stops cancelled activation work when its mode write is %s", + "finishes committed persistence but skips cancelled activation work when its mode write is %s", async (stage) => { await provider.setValue("mode", "code") const manager = provider.providerSettingsManager @@ -4779,54 +4780,66 @@ describe("ClineProvider", () => { await vi.waitFor(() => expect(select).toHaveBeenCalledTimes(stage === "queued" ? 2 : 1)) controller.abort() release() - const result = - stage === "queued" - ? expect(activation).rejects.toMatchObject({ - name: "AbortError", - message: "This operation was aborted", - }) - : expect(activation).resolves.toBeUndefined() - await Promise.all([preceding, result]) + await Promise.all([preceding, activation]) + + expect(write).toHaveBeenCalledTimes(stage === "queued" ? 2 : 1) + expect(provider["localModeConfigIds"].get("code")).toBe("selected-id") - expect(write).toHaveBeenCalledOnce() - expect(provider["localModeConfigIds"].get("code")).toBe( - stage === "queued" ? "previous-id" : "selected-id", - ) expect(rebuild).not.toHaveBeenCalled() expect(sticky).not.toHaveBeenCalled() }, ) - it("skips context writes when disposed during an activation's profile read", async () => { - vi.spyOn(provider.providerSettingsManager, "activateProfile").mockResolvedValue({ - name: "closed", - id: "closed-id", - apiProvider: providerIdentifiers.anthropic, - }) - let release = () => {} - const pending = new Promise((resolve) => { - release = resolve - }) - const list = vi.spyOn(provider.providerSettingsManager, "listConfig").mockImplementationOnce(async () => { - await pending - return [] - }) - const unlocked = vi.fn(provider["activateProviderProfileUnlocked"].bind(provider)) - provider["activateProviderProfileUnlocked"] = unlocked - const activation = expect(provider.activateProviderProfile({ name: "closed" })).rejects.toThrow( - "Provider disposed", - ) - await vi.waitFor(() => expect(list).toHaveBeenCalledOnce()) - const contextWrite = vi.spyOn(provider.contextProxy, "setValue") - const settingsWrite = vi.spyOn(provider.contextProxy, "setProviderSettings") - const run = expect(unlocked.mock.results[0].value).rejects.toThrow("Provider disposed") - await provider.dispose() - release() - await Promise.all([activation, run]) + it.each([false, true])( + "finishes committed activation persistence after disposal (context failure: %s)", + async (fails) => { + const manager = provider.providerSettingsManager + await provider.setValue("mode", "code") + await manager.import({ + currentApiConfigName: "opened", + apiConfigs: { + opened: { id: "opened-id", apiProvider: providerIdentifiers.anthropic }, + closed: { id: "closed-id", apiProvider: providerIdentifiers.anthropic }, + }, + modeApiConfigs: { code: "opened-id" }, + }) + let release = () => {} + const pending = new Promise((resolve) => { + release = resolve + }) + const originalList = manager.listConfig.bind(manager) + const list = vi.spyOn(manager, "listConfig").mockImplementationOnce(async () => { + await pending + return originalList() + }) + const rebuild = vi.fn(provider["updateTaskApiHandlerIfNeeded"].bind(provider)) + provider["updateTaskApiHandlerIfNeeded"] = rebuild + const sticky = vi.fn(provider["persistStickyProviderProfileToCurrentTask"].bind(provider)) + provider["persistStickyProviderProfileToCurrentTask"] = sticky + const activation = provider.activateProviderProfile({ name: "closed" }) + const result = fails + ? expect(activation).rejects.toThrow( + "Profile activation may be partially persisted: settings failure", + ) + : expect(activation).resolves.toBeUndefined() + await vi.waitFor(() => expect(list).toHaveBeenCalledOnce()) + await expect(manager["load"]()).resolves.toMatchObject({ currentApiConfigName: "closed" }) + if (fails) + vi.spyOn(provider.contextProxy, "setProviderSettings").mockRejectedValueOnce( + new Error("settings failure"), + ) + await provider.dispose() + release() + await result - expect(contextWrite).not.toHaveBeenCalled() - expect(settingsWrite).not.toHaveBeenCalled() - }) + if (!fails) { + expect(provider.getValue("currentApiConfigName")).toBe("closed") + await expect(manager.getModeConfigId("code")).resolves.toBe("closed-id") + } + expect(rebuild).not.toHaveBeenCalled() + expect(sticky).not.toHaveBeenCalled() + }, + ) it("invalidates a closed tab's queued activations while a reopened tab can finish its choice", async () => { await provider.setValue("mode", "code") @@ -4873,27 +4886,27 @@ describe("ClineProvider", () => { tab["updateTaskApiHandlerIfNeeded"] = rebuild const sticky = vi.fn(tab["persistStickyProviderProfileToCurrentTask"].bind(tab)) tab["persistStickyProviderProfileToCurrentTask"] = sticky - const active = expect( - tab.activateProviderProfile({ name: "closed" }, { skipCurrentTaskRebuild: true }), - ).rejects.toThrow("Provider disposed") + const active = tab.activateProviderProfile({ name: "closed" }, { skipCurrentTaskRebuild: true }) await vi.waitFor(() => expect(select).toHaveBeenCalledOnce()) const queued = expect( tab.activateProviderProfile({ name: "closed" }, { skipCurrentTaskRebuild: true }), ).rejects.toThrow("Provider disposed") await tab.dispose() - await Promise.all([active, queued]) + await queued reopened = makeTab() - vi.spyOn(reopened.providerSettingsManager, "activateProfile").mockResolvedValue({ + const freshActivate = vi.spyOn(reopened.providerSettingsManager, "activateProfile").mockResolvedValue({ name: "reopened", id: "reopened-id", apiProvider: providerIdentifiers.anthropic, }) const fresh = reopened.activateProviderProfile({ name: "reopened" }, { skipCurrentTaskRebuild: true }) + await new Promise((resolve) => setImmediate(resolve)) + expect(freshActivate).not.toHaveBeenCalled() release() - await Promise.all([first, fresh]) + await Promise.all([first, active, fresh]) expect(activate).toHaveBeenCalledOnce() - expect(write).not.toHaveBeenCalled() + expect(write).toHaveBeenCalledOnce() expect(rebuild).not.toHaveBeenCalled() expect(sticky).not.toHaveBeenCalled() await expect(manager.getModeConfigId("code")).resolves.toBe("reopened-id") @@ -5455,6 +5468,7 @@ describe("ClineProvider", () => { expect(provider.providerSettingsManager.activateProfile).toHaveBeenCalledWith( { id: "config-id-123" }, expect.any(AbortSignal), + expect.any(Function), ) }) @@ -5989,6 +6003,7 @@ describe("ClineProvider", () => { expect(provider.providerSettingsManager.activateProfile).toHaveBeenCalledWith( { name: "saved-config" }, expect.any(AbortSignal), + expect.any(Function), ) expect(mockContext.globalState.update).toHaveBeenCalledWith("currentApiConfigName", "saved-config") diff --git a/src/core/webview/__tests__/ClineProvider.sticky-mode.spec.ts b/src/core/webview/__tests__/ClineProvider.sticky-mode.spec.ts index 6e6a2c5b51..4d5553b417 100644 --- a/src/core/webview/__tests__/ClineProvider.sticky-mode.spec.ts +++ b/src/core/webview/__tests__/ClineProvider.sticky-mode.spec.ts @@ -777,7 +777,11 @@ describe("ClineProvider - Sticky Mode", () => { // Restore the task from history await provider.createTaskWithHistoryItem(historyItem) - expect(activate).toHaveBeenCalledWith({ name: "architect-config" }, expect.any(AbortSignal)) + expect(activate).toHaveBeenCalledWith( + { name: "architect-config" }, + expect.any(AbortSignal), + expect.any(Function), + ) await expect(provider.providerSettingsManager.getModeConfigId("architect")).resolves.toBe(codeConfigId) // Verify that the mode was restored diff --git a/src/extension/__tests__/api-configuration.spec.ts b/src/extension/__tests__/api-configuration.spec.ts index 6106b95fe9..b5d10380e0 100644 --- a/src/extension/__tests__/api-configuration.spec.ts +++ b/src/extension/__tests__/api-configuration.spec.ts @@ -28,7 +28,11 @@ describe("API - configuration", () => { ]), }, profileMutationAbortController: new AbortController(), - modeProfileState: { reset: undefined, activeMutationSignals: new Set() }, + modeProfileState: { + reset: undefined, + activeMutationSignals: new Set(), + committingMutationSignals: new Set(), + }, localModeConfigIds: new Map(), modeConfigWriteOwners: new Map(), modeConfigWrites: new Map>(), From 54d19f44668e71758a275fd5246cbb847c07b492 Mon Sep 17 00:00:00 2001 From: Elliott de Launay Date: Wed, 11 Nov 2026 14:26:10 +0000 Subject: [PATCH 20/30] fix: await committed profile outcomes and share window storage locking --- src/core/webview/ClineProvider.ts | 35 ++-- .../ClineProvider.apiHandlerRebuild.spec.ts | 13 +- .../webview/__tests__/ClineProvider.spec.ts | 180 +++++++++++++++++- 3 files changed, 205 insertions(+), 23 deletions(-) diff --git a/src/core/webview/ClineProvider.ts b/src/core/webview/ClineProvider.ts index a2bdd8dd0a..a941f03450 100644 --- a/src/core/webview/ClineProvider.ts +++ b/src/core/webview/ClineProvider.ts @@ -355,6 +355,7 @@ export class ClineProvider return Promise.reject(new Error("Provider profile mutation cancelled by settings reset")) } const controller = new AbortController() + let timedOut = false const signal = AbortSignal.any([controller.signal, this.profileMutationAbortController.signal]) const invoke = async () => { signal.throwIfAborted() @@ -373,6 +374,7 @@ export class ClineProvider const callerResult = this.withProviderProfileMutationTimeout( run, () => { + timedOut = true if (options.runToCompletion || this.modeProfileState.committingMutationSignals.has(signal)) { this.log("Provider profile mutation timed out; waiting for it to finish before the next mutation") return @@ -393,14 +395,12 @@ export class ClineProvider this.log("Provider profile mutation completed after cancellation") } }, - (error) => { + () => { this.modeProfileState.mutations.delete(run) this.modeProfileState.committingMutationSignals.delete(signal) - if (signal.aborted) { + if (signal.aborted || timedOut) { this.log( - `Provider profile mutation errored after cancellation: ${ - error instanceof Error ? error.message : String(error) - }`, + "Provider profile mutation failed after cancellation or timeout; settings may be partially persisted", ) } }, @@ -410,7 +410,7 @@ export class ClineProvider this.providerProfileMutationQueue = callerResult.then( () => undefined, async () => { - if (options.runToCompletion || this.modeProfileState.committingMutationSignals.has(signal)) { + if (options.runToCompletion) { await run.catch(() => {}) } else { // Cancelling a queued item must not bypass an earlier committing mutation. @@ -431,7 +431,9 @@ export class ClineProvider const timeout = new Promise((_, reject) => { timeoutId = setTimeout(() => { onTimeout() - reject(new Error("Provider profile mutation timed out")) + if (!this.modeProfileState.committingMutationSignals.has(mutationSignal)) { + reject(new Error("Provider profile mutation timed out")) + } }, ClineProvider.PENDING_OPERATION_TIMEOUT_MS) }) let onAbort = () => {} @@ -473,7 +475,10 @@ export class ClineProvider * alone lets another window's profile selection leak into this window's tasks. * The window's focus tracker is shared by sidebar and tab providers, so it keys their shared choices. */ - private static readonly modeProfilesByWindow = new WeakMap() + private static readonly modeProfilesByWindow = new WeakMap< + WebviewFocusTracker, + { state: ClineProvider["modeProfileState"]; manager: ProviderSettingsManager } + >() private modeProfileState = { localIds: new Map(), @@ -545,12 +550,16 @@ export class ClineProvider this._workspaceTracker = new WorkspaceTracker(this) - this.providerSettingsManager = new ProviderSettingsManager(this.context) const windowModeProfiles = ClineProvider.modeProfilesByWindow.get(webviewFocusTracker) if (windowModeProfiles) { - this.modeProfileState = windowModeProfiles + this.modeProfileState = windowModeProfiles.state + this.providerSettingsManager = windowModeProfiles.manager } else { - ClineProvider.modeProfilesByWindow.set(webviewFocusTracker, this.modeProfileState) + this.providerSettingsManager = new ProviderSettingsManager(this.context) + ClineProvider.modeProfilesByWindow.set(webviewFocusTracker, { + state: this.modeProfileState, + manager: this.providerSettingsManager, + }) this.captureInitialModeConfigIds() } @@ -2240,8 +2249,8 @@ export class ClineProvider // Provider Profile Management private captureInitialModeConfigIds(): void { - this.initialModeConfigIds = this.providerSettingsManager.getModeConfigIds().catch((error) => { - this.log(`Failed to snapshot mode profile choices: ${error instanceof Error ? error.message : error}`) + this.initialModeConfigIds = this.providerSettingsManager.getModeConfigIds().catch(() => { + this.log("Failed to snapshot mode profile choices") return undefined }) } diff --git a/src/core/webview/__tests__/ClineProvider.apiHandlerRebuild.spec.ts b/src/core/webview/__tests__/ClineProvider.apiHandlerRebuild.spec.ts index 395a872010..4495f2bc50 100644 --- a/src/core/webview/__tests__/ClineProvider.apiHandlerRebuild.spec.ts +++ b/src/core/webview/__tests__/ClineProvider.apiHandlerRebuild.spec.ts @@ -643,7 +643,7 @@ describe("ClineProvider - API Handler Rebuild Guard", () => { expect(vscode.window.showErrorMessage).toHaveBeenCalledWith("errors.update_profile_model_partial") }) - test("finishes activation after the caller timed out instead of leaving a saved but inactive profile", async () => { + test("waits beyond timeout for a committing model update", async () => { vi.useFakeTimers() try { @@ -664,11 +664,11 @@ describe("ClineProvider - API Handler Rebuild Guard", () => { }) await vi.advanceTimersByTimeAsync(ClineProvider.PENDING_OPERATION_TIMEOUT_MS + 1) - await update expect(provider["providerSettingsManager"].setModeConfig).not.toHaveBeenCalled() release() await vi.advanceTimersByTimeAsync(0) + await update const manager = provider["providerSettingsManager"] expect(manager.setModeConfig).toHaveBeenCalledTimes(1) @@ -680,7 +680,7 @@ describe("ClineProvider - API Handler Rebuild Guard", () => { } }) - test("upsertProviderProfile finishes activation after the caller timed out", async () => { + test("upsertProviderProfile waits beyond timeout for its persistence outcome", async () => { vi.useFakeTimers() try { @@ -703,7 +703,6 @@ describe("ClineProvider - API Handler Rebuild Guard", () => { ) await vi.advanceTimersByTimeAsync(ClineProvider.PENDING_OPERATION_TIMEOUT_MS + 1) - await expect(upsert).resolves.toBeUndefined() const manager = provider["providerSettingsManager"] expect(manager.setModeConfig).not.toHaveBeenCalled() @@ -711,6 +710,7 @@ describe("ClineProvider - API Handler Rebuild Guard", () => { release() await vi.advanceTimersByTimeAsync(0) + await expect(upsert).resolves.toBe("test-id") expect(manager.saveConfig).toHaveBeenCalledTimes(1) expect(manager.setModeConfig).toHaveBeenCalledTimes(1) } finally { @@ -718,7 +718,7 @@ describe("ClineProvider - API Handler Rebuild Guard", () => { } }) - test("holds the next profile mutation until a timed-out model update settles", async () => { + test("holds the next profile mutation until a committing model update settles", async () => { vi.useFakeTimers() try { @@ -744,7 +744,6 @@ describe("ClineProvider - API Handler Rebuild Guard", () => { openRouterModelId: "anthropic/claude", }) await vi.advanceTimersByTimeAsync(ClineProvider.PENDING_OPERATION_TIMEOUT_MS + 1) - await update const next = provider.activateProviderProfile({ name: "other-profile" }) await vi.advanceTimersByTimeAsync(0) @@ -752,7 +751,7 @@ describe("ClineProvider - API Handler Rebuild Guard", () => { release() await vi.advanceTimersByTimeAsync(0) - await next + await Promise.all([update, next]) expect(manager.activateProfile).toHaveBeenCalledTimes(1) // One write set from the model update, one from the queued activation. diff --git a/src/core/webview/__tests__/ClineProvider.spec.ts b/src/core/webview/__tests__/ClineProvider.spec.ts index 945ebb8ce7..3496d70447 100644 --- a/src/core/webview/__tests__/ClineProvider.spec.ts +++ b/src/core/webview/__tests__/ClineProvider.spec.ts @@ -4901,12 +4901,12 @@ describe("ClineProvider", () => { }) const fresh = reopened.activateProviderProfile({ name: "reopened" }, { skipCurrentTaskRebuild: true }) await new Promise((resolve) => setImmediate(resolve)) - expect(freshActivate).not.toHaveBeenCalled() + expect(freshActivate).toHaveBeenCalledOnce() release() await Promise.all([first, active, fresh]) - expect(activate).toHaveBeenCalledOnce() - expect(write).toHaveBeenCalledOnce() + expect(activate).toHaveBeenCalledTimes(2) + expect(write).toHaveBeenCalledTimes(2) expect(rebuild).not.toHaveBeenCalled() expect(sticky).not.toHaveBeenCalled() await expect(manager.getModeConfigId("code")).resolves.toBe("reopened-id") @@ -4918,6 +4918,180 @@ describe("ClineProvider", () => { } }) + it("serializes a tab import with a sidebar mode write and publishes in persisted order", async () => { + const manager = provider.providerSettingsManager + await manager.import({ + currentApiConfigName: "chosen", + apiConfigs: { chosen: { id: "chosen-id" }, imported: { id: "imported-id" } }, + modeApiConfigs: {}, + }) + const tab = new ClineProvider( + mockContext, + mockOutputChannel, + "editor", + provider.contextProxy, + provider.webviewFocusTracker, + ) + let release = () => {} + const pending = new Promise((resolve) => { + release = resolve + }) + try { + const originalStore = vi.mocked(mockContext.secrets.store).getMockImplementation()! + const store = vi.spyOn(mockContext.secrets, "store").mockImplementationOnce(async (key, value) => { + await pending + await originalStore(key, value) + }) + const chosen = provider.setModeConfig("code", "chosen-id") + await vi.waitFor(() => expect(store).toHaveBeenCalledOnce()) + const publish = vi.fn(() => tab.adoptModeConfigIds({ code: "imported-id" })) + const imported = tab.providerSettingsManager.import( + { + currentApiConfigName: "imported", + apiConfigs: { + chosen: { id: "chosen-id" }, + imported: { id: "imported-id" }, + added: { id: "added-id" }, + }, + modeApiConfigs: { code: "imported-id" }, + }, + publish, + ) + await new Promise((resolve) => setImmediate(resolve)) + expect(publish).not.toHaveBeenCalled() + release() + await Promise.all([chosen, imported]) + + expect(publish).toHaveBeenCalledOnce() + await expect(manager.getModeConfigId("code")).resolves.toBe("imported-id") + await expect(provider["getModeConfigId"]("code")).resolves.toBe("imported-id") + await expect(tab["getModeConfigId"]("code")).resolves.toBe("imported-id") + expect(await manager.listConfig()).toEqual( + expect.arrayContaining([expect.objectContaining({ id: "added-id" })]), + ) + } finally { + release() + await tab.dispose() + } + }) + + it("does not adopt shared mappings when an import omits modeApiConfigs", async () => { + const manager = provider.providerSettingsManager + await manager.import({ + currentApiConfigName: "local", + apiConfigs: { local: { id: "local-id" }, shared: { id: "shared-id" } }, + modeApiConfigs: { code: "shared-id" }, + }) + provider.adoptModeConfigIds({ code: "local-id" }) + const fsPromises = (await import("fs/promises")).default + vi.mocked(fsPromises.readFile).mockResolvedValueOnce( + JSON.stringify({ + providerProfiles: { + currentApiConfigName: "imported", + apiConfigs: { imported: { id: "imported-id", apiProvider: providerIdentifiers.anthropic } }, + }, + globalSettings: {}, + }), + ) + const adopt = vi.spyOn(provider, "adoptModeConfigIds") + const { importSettingsFromPath } = await import("../../config/importExport") + const result = await importSettingsFromPath("/settings.json", { + providerSettingsManager: manager, + contextProxy: provider.contextProxy, + customModesManager: provider.customModesManager, + onModeConfigIdsImported: (ids) => provider.adoptModeConfigIds(ids), + }) + + expect(result.success).toBe(true) + expect(adopt).toHaveBeenCalledExactlyOnceWith({}) + await expect(manager.getModeConfigId("code")).resolves.toBe("shared-id") + await expect(provider["getModeConfigId"]("code")).resolves.toBe("local-id") + }) + + it("logs a fixed snapshot failure message without secret-storage error content", async () => { + vi.spyOn(provider.providerSettingsManager, "getModeConfigIds").mockRejectedValueOnce( + new Error("api-key-must-not-appear"), + ) + const log = vi.spyOn(provider, "log") + provider["captureInitialModeConfigIds"]() + await provider["initialModeConfigIds"] + + expect(log).toHaveBeenCalledWith("Failed to snapshot mode profile choices") + expect(log.mock.calls.flat().join("\n")).not.toContain("api-key-must-not-appear") + }) + + it.each([false, true])( + "awaits a committing activation beyond timeout and reports its outcome (context failure: %s)", + async (fails) => { + vi.useFakeTimers() + let release = () => {} + try { + const manager = provider.providerSettingsManager + await provider.setValue("mode", "code") + await manager.import({ + currentApiConfigName: "first", + apiConfigs: { + first: { id: "first-id", apiProvider: providerIdentifiers.anthropic }, + second: { id: "second-id", apiProvider: providerIdentifiers.anthropic }, + }, + modeApiConfigs: {}, + }) + const pending = new Promise((resolve) => { + release = resolve + }) + const originalList = manager.listConfig.bind(manager) + const list = vi.spyOn(manager, "listConfig").mockImplementationOnce(async () => { + await pending + return originalList() + }) + const activate = vi.spyOn(manager, "activateProfile") + let finished = false + const first = provider.activateProviderProfile({ name: "first" }) + const outcome = first.then( + () => { + finished = true + return undefined + }, + (error: unknown) => { + finished = true + return error + }, + ) + await vi.advanceTimersByTimeAsync(0) + expect(list).toHaveBeenCalledOnce() + const firstSignal = activate.mock.calls[0][1] + if (!firstSignal) throw new Error("Missing activation signal") + await vi.advanceTimersByTimeAsync(ClineProvider.PENDING_OPERATION_TIMEOUT_MS + 1) + expect(finished).toBe(false) + expect(firstSignal.aborted).toBe(false) + const second = provider.activateProviderProfile({ name: "second" }) + await vi.advanceTimersByTimeAsync(0) + expect(activate).toHaveBeenCalledOnce() + if (fails) + vi.spyOn(provider.contextProxy, "setProviderSettings").mockRejectedValueOnce( + new Error("settings failed after timeout"), + ) + release() + await vi.advanceTimersByTimeAsync(0) + const error = await outcome + if (fails) + expect(error).toMatchObject({ + name: "Error", + message: "Profile activation may be partially persisted: settings failed after timeout", + }) + else expect(error).toBeUndefined() + await second + + expect(activate).toHaveBeenCalledTimes(2) + expect(provider["modeProfileState"].committingMutationSignals.has(firstSignal)).toBe(false) + expect(provider["modeProfileState"].committingMutationSignals.size).toBe(0) + } finally { + release() + vi.useRealTimers() + } + }, + ) + it.each(["snapshot", "profiles"])("stops a cancelled mode switch during %s lookup", async (stage) => { let release = () => {} const pending = new Promise((resolve) => { From 55988d9cb3b4ae708a745d819fc6263f042e44e6 Mon Sep 17 00:00:00 2001 From: Elliott de Launay Date: Wed, 11 Nov 2026 14:56:16 +0000 Subject: [PATCH 21/30] fix: drain mode-switch writes before releasing disposed tabs --- src/core/webview/ClineProvider.ts | 12 +++- .../webview/__tests__/ClineProvider.spec.ts | 60 +++++++++++++++++++ src/eslint-suppressions.json | 2 +- 3 files changed, 72 insertions(+), 2 deletions(-) diff --git a/src/core/webview/ClineProvider.ts b/src/core/webview/ClineProvider.ts index a941f03450..e7c052e60f 100644 --- a/src/core/webview/ClineProvider.ts +++ b/src/core/webview/ClineProvider.ts @@ -2159,7 +2159,11 @@ export class ClineProvider targetTask: Task | null | undefined, signal?: AbortSignal, ): Promise { + if (signal?.aborted) return const task = targetTask + const startWrite = () => { + if (signal) this.modeProfileState.committingMutationSignals.add(signal) + } if (task) { TelemetryService.instance.captureModeSwitch(task.taskId, newMode) @@ -2170,11 +2174,13 @@ export class ClineProvider const taskHistoryItem = this.getTaskHistoryItem(task.taskId) if (taskHistoryItem) { + startWrite() await this.updateTaskHistory({ ...taskHistoryItem, mode: newMode }) } + if (signal?.aborted) return // Only update the task's mode after successful persistence. - ;(task as any)._taskMode = newMode + task["_taskMode"] = newMode } catch (error) { // If persistence fails, log the error but don't update the in-memory state. this.log( @@ -2187,7 +2193,10 @@ export class ClineProvider } } + if (signal?.aborted) return + startWrite() await this.updateGlobalState("mode", newMode) + if (signal?.aborted) return this.emit(RooCodeEventName.ModeChanged, newMode) @@ -2211,6 +2220,7 @@ export class ClineProvider // Update listApiConfigMeta first to ensure UI has latest data. await this.updateGlobalState("listApiConfigMeta", listApiConfig) + if (signal?.aborted) return // If this mode has a saved config, use it. if (savedConfigId) { diff --git a/src/core/webview/__tests__/ClineProvider.spec.ts b/src/core/webview/__tests__/ClineProvider.spec.ts index 3496d70447..31195f6893 100644 --- a/src/core/webview/__tests__/ClineProvider.spec.ts +++ b/src/core/webview/__tests__/ClineProvider.spec.ts @@ -15,6 +15,7 @@ import { type ClineMessage, type ExtensionMessage, type ExtensionState, + type HistoryItem, type WebviewMessage, ORGANIZATION_ALLOW_ALL, DEFAULT_CHECKPOINT_TIMEOUT_SECONDS, @@ -5092,6 +5093,65 @@ describe("ClineProvider", () => { }, ) + it.each([false, true])( + "drains a delayed mode-switch history write before another tab selects a mode (disposed: %s)", + async (dispose) => { + const task = new Task(defaultTaskOptions) + task["_taskMode"] = "code" + const history: HistoryItem = { + id: task.taskId, + number: 1, + ts: 1, + task: "Mode switch", + mode: "code", + tokensIn: 0, + tokensOut: 0, + totalCost: 0, + } + provider["getTaskHistoryItem"] = vi.fn().mockReturnValue(history) + let release = () => {} + const pending = new Promise((resolve) => { + release = resolve + }) + const write = vi.spyOn(provider, "updateTaskHistory").mockImplementationOnce(async () => { + await pending + return [history] + }) + const first = provider.handleModeSwitch("ask", task) + const outcome = first.then( + () => undefined, + (error: unknown) => error, + ) + await vi.waitFor(() => expect(write).toHaveBeenCalledOnce()) + if (dispose) await provider.dispose() + const tab = new ClineProvider( + mockContext, + mockOutputChannel, + "editor", + provider.contextProxy, + provider.webviewFocusTracker, + ) + try { + vi.spyOn(tab, "postStateToWebview").mockResolvedValue(undefined) + let finished = false + const second = tab.handleModeSwitch("architect", null).then(() => { + finished = true + }) + await new Promise((resolve) => setImmediate(resolve)) + expect(finished).toBe(false) + release() + await second + + expect(await outcome).toBeUndefined() + expect(tab.getValue("mode")).toBe("architect") + expect(task["_taskMode"]).toBe(dispose ? "code" : "ask") + } finally { + release() + await tab.dispose() + } + }, + ) + it.each(["snapshot", "profiles"])("stops a cancelled mode switch during %s lookup", async (stage) => { let release = () => {} const pending = new Promise((resolve) => { diff --git a/src/eslint-suppressions.json b/src/eslint-suppressions.json index e59c4b6cfc..e7134879f6 100644 --- a/src/eslint-suppressions.json +++ b/src/eslint-suppressions.json @@ -911,7 +911,7 @@ }, "core/webview/ClineProvider.ts": { "@typescript-eslint/no-explicit-any": { - "count": 7 + "count": 6 } }, "core/webview/__tests__/ClineProvider.apiHandlerRebuild.spec.ts": { From bcf5b95c7bf195c4930b56773a460d10b005339a Mon Sep 17 00:00:00 2001 From: Elliott de Launay Date: Wed, 11 Nov 2026 15:32:08 +0000 Subject: [PATCH 22/30] fix: finish inactive profile saves after tab disposal --- src/core/webview/ClineProvider.ts | 4 +- .../webview/__tests__/ClineProvider.spec.ts | 62 +++++++++++++++++++ .../__tests__/api-configuration.spec.ts | 7 ++- 3 files changed, 69 insertions(+), 4 deletions(-) diff --git a/src/core/webview/ClineProvider.ts b/src/core/webview/ClineProvider.ts index b916c85508..aa58ea99dd 100644 --- a/src/core/webview/ClineProvider.ts +++ b/src/core/webview/ClineProvider.ts @@ -2543,11 +2543,9 @@ export class ClineProvider // we rely on the `ContextProxy`'s data store and in other cases // we rely on the `ProviderSettingsManager`'s data store. It might // be simpler to unify these two. - if (activate) this.modeProfileState.committingMutationSignals.add(signal) + this.modeProfileState.committingMutationSignals.add(signal) const id = await this.providerSettingsManager.saveConfig(name, providerSettings) - if (signal.aborted && !activate) return id - if (activate) { const { mode } = await this.getState() diff --git a/src/core/webview/__tests__/ClineProvider.spec.ts b/src/core/webview/__tests__/ClineProvider.spec.ts index d3f3f747f9..964276cd76 100644 --- a/src/core/webview/__tests__/ClineProvider.spec.ts +++ b/src/core/webview/__tests__/ClineProvider.spec.ts @@ -51,6 +51,7 @@ import { WebviewFocusTracker } from "../WebviewFocusTracker" import { resolveChatProvider } from "../../../activate/resolveChatProvider" // Mock setup must come before imports. +vi.mock("@roo-code/ipc", () => ({ IpcServer: class {} })) vi.mock("../../prompts/sections/custom-instructions") vi.mock("p-wait-for", () => ({ @@ -4992,6 +4993,57 @@ describe("ClineProvider", () => { }, ) + it("finishes an inactive profile save after tab disposal and prevents a duplicate API retry", async () => { + const { API } = await import("../../../extension/api") + const { makeClineProviderFactory } = await import("../../../test-utils/provider") + const tab = new ClineProvider( + mockContext, + mockOutputChannel, + "editor", + provider.contextProxy, + provider.webviewFocusTracker, + ) + const manager = provider.providerSettingsManager + const originalSave = manager.saveConfig.bind(manager) + let release = () => {} + const pending = new Promise((resolve) => { + release = resolve + }) + const save = vi.spyOn(manager, "saveConfig").mockImplementationOnce(async (...args) => { + await pending + return originalSave(...args) + }) + const post = vi.spyOn(tab, "postStateToWebview").mockResolvedValue(undefined) + try { + let settled = false + const saving = tab + .upsertProviderProfile("inactive", { apiProvider: providerIdentifiers.anthropic }, false) + .finally(() => { + settled = true + }) + await vi.waitFor(() => expect(save).toHaveBeenCalledOnce()) + await tab.dispose() + await new Promise((resolve) => setImmediate(resolve)) + expect(settled).toBe(false) + release() + const id = await saving + expect(id).toEqual(expect.any(String)) + expect(provider.getProviderProfileEntry("inactive")).toMatchObject({ id, name: "inactive" }) + expect(post).not.toHaveBeenCalled() + const api = new API(mockOutputChannel, provider, makeClineProviderFactory()) + await expect( + api.createProfile("inactive", { apiProvider: providerIdentifiers.openai }, false), + ).rejects.toThrow('Profile with name "inactive" already exists') + expect(save).toHaveBeenCalledOnce() + await expect(manager.getProfile({ name: "inactive" })).resolves.toMatchObject({ + apiProvider: providerIdentifiers.anthropic, + }) + } finally { + release() + await tab.dispose() + } + }) + it("invalidates a closed tab's queued activations while a reopened tab can finish its choice", async () => { await provider.setValue("mode", "code") const manager = provider.providerSettingsManager @@ -5513,6 +5565,16 @@ describe("ClineProvider", () => { await expect(provider["getModeConfigId"]("architect")).resolves.toBe("chosen-id") }) + it("falls back to the shared mapping when the opening snapshot profile was removed", async () => { + provider["initialModeConfigIds"] = Promise.resolve({ code: "removed-id" }) + existingProfiles("shared-id") + vi.spyOn(provider.providerSettingsManager, "getModeConfigId").mockResolvedValue("shared-id") + + expect(provider["localModeConfigIds"].has("code")).toBe(false) + await expect(provider["getModeConfigId"]("code")).resolves.toBe("shared-id") + expect(provider.providerSettingsManager.getModeConfigId).toHaveBeenCalledExactlyOnceWith("code") + }) + it("drops a local choice whose profile was removed and falls back to the shared mapping", async () => { provider["initialModeConfigIds"] = Promise.resolve({}) vi.spyOn(provider.providerSettingsManager, "setModeConfig").mockResolvedValue(undefined) diff --git a/src/extension/__tests__/api-configuration.spec.ts b/src/extension/__tests__/api-configuration.spec.ts index c5a285ca71..521a6a2de6 100644 --- a/src/extension/__tests__/api-configuration.spec.ts +++ b/src/extension/__tests__/api-configuration.spec.ts @@ -81,9 +81,10 @@ describe("API - configuration", () => { const pending = new Promise((resolve) => { release = resolve }) + const cancellationError = new Error("Mode profile write cancelled by settings reset") const setModeConfig = vi .fn() - .mockRejectedValueOnce(new Error("Mode profile write cancelled by settings reset")) + .mockRejectedValueOnce(cancellationError) .mockImplementationOnce(async () => { await pending }) @@ -109,6 +110,7 @@ describe("API - configuration", () => { .finally(() => { outcomes.push("settled") }) + const failure = updated.catch((error: unknown) => error) const failed = expect(updated).rejects.toThrow("Configuration update may be partially persisted") await vi.waitFor(() => expect(setModeConfig).toHaveBeenCalledTimes(2)) expect(setValues).toHaveBeenCalledOnce() @@ -116,6 +118,9 @@ describe("API - configuration", () => { expect(outcomes).toEqual([]) release() await failed + const error = await failure + expect(error).toBeInstanceOf(Error) + if (error instanceof Error) expect(error.cause).toBe(cancellationError) expect(postStateToWebview).not.toHaveBeenCalled() }) From f9bbfb9efdf8fc7817e6ae15be34d6175dcb84dd Mon Sep 17 00:00:00 2001 From: Elliott de Launay Date: Wed, 11 Nov 2026 15:58:27 +0000 Subject: [PATCH 23/30] fix: finish committed mode and profile history together --- src/core/config/ProviderSettingsManager.ts | 11 +- .../__tests__/ProviderSettingsManager.spec.ts | 41 ++++ src/core/webview/ClineProvider.ts | 178 +++++++--------- .../ClineProvider.apiHandlerRebuild.spec.ts | 7 + .../webview/__tests__/ClineProvider.spec.ts | 191 +++++++++++++++++- .../ClineProvider.sticky-profile.spec.ts | 6 +- 6 files changed, 323 insertions(+), 111 deletions(-) diff --git a/src/core/config/ProviderSettingsManager.ts b/src/core/config/ProviderSettingsManager.ts index 61893b3f9a..de4f229a72 100644 --- a/src/core/config/ProviderSettingsManager.ts +++ b/src/core/config/ProviderSettingsManager.ts @@ -416,10 +416,18 @@ export class ProviderSettingsManager { * Preserves the ID from the input 'config' object if it exists, * otherwise generates a new one (for creation scenarios). */ - public async saveConfig(name: string, config: ProviderSettingsWithId): Promise { + public async saveConfig( + name: string, + config: ProviderSettingsWithId, + signal?: AbortSignal, + onPersisting?: () => void, + ): Promise { + signal?.throwIfAborted() try { return await this.lock(async () => { + signal?.throwIfAborted() const providerProfiles = await this.load() + signal?.throwIfAborted() // Preserve the existing ID if this is an update to an existing config. const existingId = providerProfiles.apiConfigs[name]?.id const id = config.id || existingId || this.generateId() @@ -435,6 +443,7 @@ export class ProviderSettingsManager { ? providerSettingsWithIdSchema.passthrough().parse(normalizedConfig) : discriminatedProviderSettingsWithIdSchema.parse(normalizedConfig) providerProfiles.apiConfigs[name] = { ...filteredConfig, id } + onPersisting?.() await this.store(providerProfiles) return id }) diff --git a/src/core/config/__tests__/ProviderSettingsManager.spec.ts b/src/core/config/__tests__/ProviderSettingsManager.spec.ts index 875cdfeb1c..401c19d0da 100644 --- a/src/core/config/__tests__/ProviderSettingsManager.spec.ts +++ b/src/core/config/__tests__/ProviderSettingsManager.spec.ts @@ -119,6 +119,47 @@ describe("ProviderSettingsManager", () => { expect(published).toHaveBeenCalledTimes(fails ? 0 : 1) }) + it.each(["lock", "load"] as const)( + "checks save cancellation during %s before announcing a commit", + async (stage) => { + await providerSettingsManager.getModeConfigIds() + mockSecrets.get.mockClear() + mockSecrets.store.mockClear() + let release = () => {} + const pending = new Promise((resolve) => { + release = resolve + }) + const entered = vi.fn() + let locked = Promise.resolve() + if (stage === "lock") { + locked = providerSettingsManager["lock"](async () => { + entered() + await pending + }) + } else { + mockSecrets.get.mockImplementationOnce(async () => { + entered() + await pending + return null + }) + } + const controller = new AbortController() + const committing = vi.fn() + const saved = providerSettingsManager.saveConfig("selected", {}, controller.signal, committing) + const result = expect(saved).rejects.toMatchObject({ + name: "Error", + message: "Failed to save config: AbortError: This operation was aborted", + }) + await vi.waitFor(() => expect(entered).toHaveBeenCalledOnce()) + controller.abort() + release() + await Promise.all([locked, result]) + expect(mockSecrets.get).toHaveBeenCalledTimes(stage === "lock" ? 0 : 1) + expect(mockSecrets.store).not.toHaveBeenCalled() + expect(committing).not.toHaveBeenCalled() + }, + ) + it.each([false, true])("checks cancellation after waiting for the storage lock (cancelled: %s)", async (cancel) => { let release = () => {} const pending = new Promise((resolve) => { diff --git a/src/core/webview/ClineProvider.ts b/src/core/webview/ClineProvider.ts index aa58ea99dd..d902a4d4aa 100644 --- a/src/core/webview/ClineProvider.ts +++ b/src/core/webview/ClineProvider.ts @@ -2161,100 +2161,65 @@ export class ClineProvider signal?: AbortSignal, ): Promise { if (signal?.aborted) return - const task = targetTask - const startWrite = () => { - if (signal) this.modeProfileState.committingMutationSignals.add(signal) - } - - if (task) { - TelemetryService.instance.captureModeSwitch(task.taskId, newMode) - task.emit(RooCodeEventName.TaskModeSwitched, task.taskId, newMode) - - try { - // Update the task history with the new mode first. - const taskHistoryItem = this.getTaskHistoryItem(task.taskId) - - if (taskHistoryItem) { - startWrite() - await this.updateTaskHistory({ ...taskHistoryItem, mode: newMode }) - } - if (signal?.aborted) return - - // Only update the task's mode after successful persistence. - task["_taskMode"] = newMode - } catch (error) { - // If persistence fails, log the error but don't update the in-memory state. - this.log( - `Failed to persist mode switch for task ${task.taskId}: ${error instanceof Error ? error.message : String(error)}`, - ) - - // Optionally, we could emit an event to notify about the failure. - // This ensures the in-memory state remains consistent with persisted state. - throw error - } - } - - if (signal?.aborted) return - startWrite() - await this.updateGlobalState("mode", newMode) - if (signal?.aborted) return - - this.emit(RooCodeEventName.ModeChanged, newMode) - - // If workspace lock is on, keep the current API config — don't load mode-specific config const lockApiConfigAcrossModes = this.context.workspaceState.get("lockApiConfigAcrossModes", false) - if (lockApiConfigAcrossModes) { - if (targetTask !== null) { - await this.postStateToWebview() + let profiles: ProviderSettingsEntry[] | undefined + let profileName: string | undefined + // Resolve the choice before any writes so cancellation during a read leaves no partial switch. + if (!lockApiConfigAcrossModes) { + const id = await this.getModeConfigId(newMode, signal) + if (signal?.aborted) return + profiles = await this.providerSettingsManager.listConfig() + if (signal?.aborted) return + const profile = profiles.find((entry) => entry.id === id) + if (profile) { + const settings = await this.providerSettingsManager.getProfile({ name: profile.name }) + if (signal?.aborted) return + // Empty CLI profiles must not replace working runtime settings. + if (settings.apiProvider) profileName = profile.name } - return } if (signal?.aborted) return - - // Load the saved API config for the new mode if it exists. - const savedConfigId = await this.getModeConfigId(newMode, signal) - if (signal?.aborted) return - const listApiConfig = await this.providerSettingsManager.listConfig() - - if (signal?.aborted) return - - // Update listApiConfigMeta first to ensure UI has latest data. - await this.updateGlobalState("listApiConfigMeta", listApiConfig) - if (signal?.aborted) return - - // If this mode has a saved config, use it. - if (savedConfigId) { - const profile = listApiConfig.find(({ id }) => id === savedConfigId) - - if (profile?.name) { - // Check if the profile has actual API configuration (not just an id). - // In CLI mode, the ProviderSettingsManager may return empty default profiles - // that only contain 'id' and 'name' fields. Activating such a profile would - // overwrite the CLI's working API configuration with empty settings. - // Skip activation if the profile has no apiProvider set - this indicates - // an unconfigured/empty profile. - const fullProfile = await this.providerSettingsManager.getProfile({ name: profile.name }) - const hasActualSettings = !!fullProfile.apiProvider - - if (hasActualSettings) { - await this.activateProviderProfileUnlocked( - { name: profile.name }, - { persistModeConfig: false, skipCurrentTaskRebuild: targetTask === null }, - signal, - ) - } else { - // The task will continue with the current/default configuration. + if (signal) this.modeProfileState.committingMutationSignals.add(signal) + try { + if (targetTask) { + TelemetryService.instance.captureModeSwitch(targetTask.taskId, newMode) + targetTask.emit(RooCodeEventName.TaskModeSwitched, targetTask.taskId, newMode) + const history = this.getTaskHistoryItem(targetTask.taskId) + if (history) { + // Persist the mode and sticky profile together for consistent restoration after disposal. + await this.updateTaskHistory({ + ...history, + mode: newMode, + ...(profileName ? { apiConfigName: profileName } : {}), + }) } - } else { - // The task will continue with the current/default configuration. + targetTask["_taskMode"] = newMode + if (profileName) targetTask.setTaskApiConfigName(profileName) } + // Once a write starts, drain the whole persistence sequence before another tab can write. + await this.updateGlobalState("mode", newMode) + if (profiles) await this.updateGlobalState("listApiConfigMeta", profiles) + if (profileName) { + await this.activateProviderProfileUnlocked( + { name: profileName }, + { + persistModeConfig: false, + persistTaskHistory: false, + skipCurrentTaskRebuild: targetTask === null, + }, + signal, + ) + } + } catch (error) { + throw new Error( + `Mode switch may be partially persisted: ${error instanceof Error ? error.message : String(error)}`, + { cause: error }, + ) } - if (signal?.aborted) return - if (targetTask !== null) { - await this.postStateToWebview() - } + this.emit(RooCodeEventName.ModeChanged, newMode) + if (targetTask !== null) await this.postStateToWebview() } // Provider Profile Management @@ -2538,13 +2503,15 @@ export class ClineProvider signal: AbortSignal, ): Promise { signal.throwIfAborted() + const task = this.getCurrentTask() // TODO: Do we need to be calling `activateProfile`? It's not // clear to me what the source of truth should be; in some cases // we rely on the `ContextProxy`'s data store and in other cases // we rely on the `ProviderSettingsManager`'s data store. It might // be simpler to unify these two. - this.modeProfileState.committingMutationSignals.add(signal) - const id = await this.providerSettingsManager.saveConfig(name, providerSettings) + const id = await this.providerSettingsManager.saveConfig(name, providerSettings, signal, () => { + this.modeProfileState.committingMutationSignals.add(signal) + }) if (activate) { const { mode } = await this.getState() @@ -2572,15 +2539,13 @@ export class ClineProvider ) if (failedActivation) throw failedActivation.reason + if (task) await this.persistStickyProviderProfileToCurrentTask(name, { task, throwOnFailure: true }) if (signal.aborted) return id // Change the provider for the current task. // TODO: We should rename `buildApiHandler` for clarity (e.g. `getProviderClient`). this.updateTaskApiHandlerIfNeeded(providerSettings, { forceRebuild: true }) - - // Keep the current task's sticky provider profile in sync with the newly-activated profile. - await this.persistStickyProviderProfileToCurrentTask(name) } else { await this.updateGlobalState("listApiConfigMeta", await this.providerSettingsManager.listConfig()) } @@ -2616,10 +2581,15 @@ export class ClineProvider private async persistStickyProviderProfileToCurrentTask( apiConfigName: string, - options: { skipCurrentTaskRebuild?: boolean; expectedCurrentTaskId?: string } = {}, + options: { + skipCurrentTaskRebuild?: boolean + expectedCurrentTaskId?: string + task?: Task + throwOnFailure?: boolean + } = {}, ): Promise { if (options.skipCurrentTaskRebuild) return - const task = this.getCurrentTask() + const task = options.task ?? this.getCurrentTask() if (!task || (options.expectedCurrentTaskId && task.taskId !== options.expectedCurrentTaskId)) { return } @@ -2635,12 +2605,13 @@ export class ClineProvider await this.updateTaskHistory({ ...taskHistoryItem, apiConfigName }) } } catch (error) { - // If persistence fails, log the error but don't fail the profile switch. + // Log failures; committed activations also propagate them as partial persistence. this.log( `Failed to persist provider profile switch for task ${task.taskId}: ${ error instanceof Error ? error.message : String(error) }`, ) + if (options.throwOnFailure) throw error } } @@ -2669,7 +2640,15 @@ export class ClineProvider }, signal: AbortSignal = this.profileMutationAbortController.signal, ): Promise { - signal.throwIfAborted() + const completingSwitch = this.modeProfileState.committingMutationSignals.has(signal) + if (!completingSwitch) signal.throwIfAborted() + const persistenceSignal = completingSwitch ? new AbortController().signal : signal + const task = this.getCurrentTask() + const stickyTask = + !options?.skipCurrentTaskRebuild && + (!options?.expectedCurrentTaskId || task?.taskId === options.expectedCurrentTaskId) + ? task + : undefined const tracked = this.modeProfileState.activeMutationSignals.has(signal) let persistenceStarted = false let persistenceFinished = false @@ -2680,7 +2659,7 @@ export class ClineProvider try { const { name, id, ...providerSettings } = await this.providerSettingsManager.activateProfile( args, - signal, + persistenceSignal, startPersistence, ) // Returning from activateProfile confirms that its active-profile write committed. @@ -2704,6 +2683,9 @@ export class ClineProvider const { mode } = await this.getState() if (id && persistModeConfig) await this.setModeConfig(mode, id, signal) + if (persistTaskHistory && stickyTask) { + await this.persistStickyProviderProfileToCurrentTask(name, { task: stickyTask, throwOnFailure: true }) + } persistenceFinished = true if (signal.aborted) return @@ -2713,12 +2695,6 @@ export class ClineProvider skipCurrentTaskRebuild, expectedCurrentTaskId, }) - if (persistTaskHistory) { - await this.persistStickyProviderProfileToCurrentTask(name, { - skipCurrentTaskRebuild, - expectedCurrentTaskId, - }) - } if (signal.aborted) return if (!skipCurrentTaskRebuild) await this.postStateToWebview() if (signal.aborted) return diff --git a/src/core/webview/__tests__/ClineProvider.apiHandlerRebuild.spec.ts b/src/core/webview/__tests__/ClineProvider.apiHandlerRebuild.spec.ts index 4495f2bc50..f7373efb0b 100644 --- a/src/core/webview/__tests__/ClineProvider.apiHandlerRebuild.spec.ts +++ b/src/core/webview/__tests__/ClineProvider.apiHandlerRebuild.spec.ts @@ -696,6 +696,13 @@ describe("ClineProvider - API Handler Rebuild Guard", () => { return realGetState() }) + vi.mocked(provider.providerSettingsManager.saveConfig).mockImplementationOnce( + async (_name, _config, _signal, onPersisting) => { + onPersisting?.() + return "test-id" + }, + ) + const upsert = provider.upsertProviderProfile( "test-config", { apiProvider: providerIdentifiers.openrouter, openRouterModelId: "anthropic/claude" }, diff --git a/src/core/webview/__tests__/ClineProvider.spec.ts b/src/core/webview/__tests__/ClineProvider.spec.ts index 964276cd76..c3ef2c5f63 100644 --- a/src/core/webview/__tests__/ClineProvider.spec.ts +++ b/src/core/webview/__tests__/ClineProvider.spec.ts @@ -4757,7 +4757,7 @@ describe("ClineProvider", () => { expect(activate).toHaveBeenCalledWith( { name: expectedName }, - { persistModeConfig: false, skipCurrentTaskRebuild: true }, + { persistModeConfig: false, persistTaskHistory: false, skipCurrentTaskRebuild: true }, undefined, ) await expect(tab["getModeConfigId"]("code")).resolves.toBe(`${expectedName}-id`) @@ -4993,6 +4993,176 @@ describe("ClineProvider", () => { }, ) + it("rejects a delegation profile lookup failure before changing the parent or creating a child", async () => { + const parent = new Task(defaultTaskOptions) + parent.getTaskMode = vi.fn().mockResolvedValue("code") + parent.getTaskApiConfigName = vi.fn().mockResolvedValue("parent-profile") + parent.apiConfiguration = { apiProvider: providerIdentifiers.anthropic } + vi.spyOn(provider, "getCurrentTask").mockReturnValue(parent) + vi.spyOn(provider.taskHistoryStore, "invalidate").mockResolvedValue(undefined) + vi.spyOn(provider.taskHistoryStore, "get").mockReturnValue(undefined) + const persist = vi.spyOn(provider.taskHistoryStore, "atomicReadAndUpdate") + const create = vi.spyOn(provider, "createTask") + const remove = vi.spyOn(provider, "removeClineFromStack") + provider["initialModeConfigIds"] = Promise.resolve({ architect: "selected-id" }) + vi.spyOn(provider.providerSettingsManager, "listConfig").mockRejectedValue( + new Error("profiles unavailable"), + ) + + await expect( + provider.delegateParentAndOpenChild({ + parentTaskId: parent.taskId, + message: "Child", + initialTodos: [], + mode: "architect", + }), + ).rejects.toThrow("profiles unavailable") + expect(provider.getCurrentTask()).toBe(parent) + expect(parent.apiConfiguration).toEqual({ apiProvider: providerIdentifiers.anthropic }) + expect(persist).not.toHaveBeenCalled() + expect(remove).not.toHaveBeenCalled() + expect(create).not.toHaveBeenCalled() + }) + + it.each(["mode switch", "profile activation"] as const)( + "restores matching mode and profile after disposal during a committed %s", + async (operation) => { + const manager = provider.providerSettingsManager + await manager.import({ + currentApiConfigName: "old", + apiConfigs: { + old: { id: "old-id", apiProvider: providerIdentifiers.anthropic }, + selected: { id: "selected-id", apiProvider: providerIdentifiers.openai }, + }, + modeApiConfigs: {}, + }) + await provider.setValue("mode", "code") + await provider.setValue("currentApiConfigName", "old") + provider.adoptModeConfigIds({ architect: "selected-id" }) + const tab = new ClineProvider( + mockContext, + mockOutputChannel, + "editor", + provider.contextProxy, + provider.webviewFocusTracker, + ) + const task = new Task(defaultTaskOptions) + task.setTaskApiConfigName = vi.fn() + let history: HistoryItem = { + id: task.taskId, + number: 1, + ts: 1, + task: "Restore", + mode: "code", + apiConfigName: "old", + tokensIn: 0, + tokensOut: 0, + totalCost: 0, + } + const current = vi.spyOn(tab, "getCurrentTask").mockReturnValue(task) + tab["getTaskHistoryItem"] = vi.fn(() => history) + let release = () => {} + const pending = new Promise((resolve) => { + release = resolve + }) + const entered = vi.fn() + vi.spyOn(tab, "updateTaskHistory").mockImplementation(async (item) => { + if (operation === "mode switch") { + entered() + await pending + } + history = item + return [history] + }) + if (operation === "profile activation") { + const originalStore = vi.mocked(mockContext.secrets.store).getMockImplementation()! + vi.spyOn(mockContext.secrets, "store").mockImplementationOnce(async (key, value) => { + entered() + await pending + await originalStore(key, value) + }) + } + try { + const changing = + operation === "mode switch" + ? tab.handleModeSwitch("architect", task) + : tab.activateProviderProfile({ name: "selected" }) + await vi.waitFor(() => expect(entered).toHaveBeenCalledOnce()) + await tab.dispose() + current.mockReturnValue(undefined) + release() + await changing + const expectedMode = operation === "mode switch" ? "architect" : "code" + expect(history).toMatchObject({ mode: expectedMode, apiConfigName: "selected" }) + vi.spyOn(provider, "postStateToWebview").mockResolvedValue(undefined) + await provider.createTaskWithHistoryItem(history) + expect(provider.getValue("mode")).toBe(expectedMode) + expect(provider.getValue("currentApiConfigName")).toBe("selected") + expect(Task).toHaveBeenLastCalledWith( + expect.objectContaining({ + historyItem: expect.objectContaining({ mode: expectedMode, apiConfigName: "selected" }), + apiConfiguration: expect.objectContaining({ apiProvider: providerIdentifiers.openai }), + }), + ) + } finally { + release() + await tab.dispose() + } + }, + ) + + it.each(["lock", "load"] as const)( + "settles a disposed tab's save before a pending %s finishes", + async (stage) => { + await provider["initialModeConfigIds"] + const tab = new ClineProvider( + mockContext, + mockOutputChannel, + "editor", + provider.contextProxy, + provider.webviewFocusTracker, + ) + const manager = tab.providerSettingsManager + let release = () => {} + const pending = new Promise((resolve) => { + release = resolve + }) + const entered = vi.fn() + let locked = Promise.resolve() + if (stage === "lock") { + locked = manager["lock"](async () => { + entered() + await pending + }) + } else { + vi.spyOn(mockContext.secrets, "get").mockImplementationOnce(async () => { + entered() + await pending + return undefined + }) + } + const store = vi.spyOn(mockContext.secrets, "store") + const save = vi.spyOn(manager, "saveConfig") + try { + const saving = tab.upsertProviderProfile("cancelled", {}, false) + await vi.waitFor(() => { + expect(entered).toHaveBeenCalledOnce() + expect(save).toHaveBeenCalledOnce() + }) + await tab.dispose() + await expect(saving).resolves.toBeUndefined() + expect(store).not.toHaveBeenCalled() + release() + await locked + await vi.waitFor(() => expect(tab["modeProfileState"].mutations.size).toBe(0)) + expect(store).not.toHaveBeenCalled() + } finally { + release() + await tab.dispose() + } + }, + ) + it("finishes an inactive profile save after tab disposal and prevents a duplicate API retry", async () => { const { API } = await import("../../../extension/api") const { makeClineProviderFactory } = await import("../../../test-utils/provider") @@ -5004,14 +5174,16 @@ describe("ClineProvider", () => { provider.webviewFocusTracker, ) const manager = provider.providerSettingsManager - const originalSave = manager.saveConfig.bind(manager) + await provider["initialModeConfigIds"] + const originalStore = vi.mocked(mockContext.secrets.store).getMockImplementation()! let release = () => {} const pending = new Promise((resolve) => { release = resolve }) - const save = vi.spyOn(manager, "saveConfig").mockImplementationOnce(async (...args) => { + const save = vi.spyOn(manager, "saveConfig") + const store = vi.spyOn(mockContext.secrets, "store").mockImplementationOnce(async (key, value) => { await pending - return originalSave(...args) + await originalStore(key, value) }) const post = vi.spyOn(tab, "postStateToWebview").mockResolvedValue(undefined) try { @@ -5021,7 +5193,7 @@ describe("ClineProvider", () => { .finally(() => { settled = true }) - await vi.waitFor(() => expect(save).toHaveBeenCalledOnce()) + await vi.waitFor(() => expect(store).toHaveBeenCalledOnce()) await tab.dispose() await new Promise((resolve) => setImmediate(resolve)) expect(settled).toBe(false) @@ -5346,7 +5518,7 @@ describe("ClineProvider", () => { expect(await outcome).toBeUndefined() expect(tab.getValue("mode")).toBe("architect") - expect(task["_taskMode"]).toBe(dispose ? "code" : "ask") + expect(task["_taskMode"]).toBe("ask") } finally { release() await tab.dispose() @@ -6883,7 +7055,12 @@ describe("ClineProvider", () => { }) // Verify config was saved - expect(provider.providerSettingsManager.saveConfig).toHaveBeenCalledWith("test-config", testApiConfig) + expect(provider.providerSettingsManager.saveConfig).toHaveBeenCalledWith( + "test-config", + testApiConfig, + expect.any(AbortSignal), + expect.any(Function), + ) // Verify state updates expect(mockContext.globalState.update).toHaveBeenCalledWith("listApiConfigMeta", [ diff --git a/src/core/webview/__tests__/ClineProvider.sticky-profile.spec.ts b/src/core/webview/__tests__/ClineProvider.sticky-profile.spec.ts index 53204ebb6e..39d8c6469e 100644 --- a/src/core/webview/__tests__/ClineProvider.sticky-profile.spec.ts +++ b/src/core/webview/__tests__/ClineProvider.sticky-profile.spec.ts @@ -1040,8 +1040,10 @@ describe("ClineProvider - Sticky Provider Profile", () => { // Mock log to verify error is logged const logSpy = vi.spyOn(provider, "log") - // Switch provider profile - should not throw - await expect(provider.activateProviderProfile({ name: "new-profile" })).resolves.not.toThrow() + // A committed profile whose sticky history failed must report partial persistence. + await expect(provider.activateProviderProfile({ name: "new-profile" })).rejects.toThrow( + "Profile activation may be partially persisted: Save failed", + ) // Verify error was logged expect(logSpy).toHaveBeenCalledWith(expect.stringContaining("Failed to persist provider profile switch")) From 897d9b677f7fa1e582274cc098027c7e77702355 Mon Sep 17 00:00:00 2001 From: Elliott de Launay Date: Thu, 12 Nov 2026 01:01:09 +0000 Subject: [PATCH 24/30] fix(profiles): remove write queue and locking from mode profile fix --- src/__tests__/extension.spec.ts | 16 - src/core/config/ProviderSettingsManager.ts | 31 +- .../__tests__/ProviderSettingsManager.spec.ts | 225 --- .../config/__tests__/importExport.spec.ts | 32 +- src/core/config/importExport.ts | 31 +- src/core/webview/ClineProvider.ts | 561 +++---- .../ClineProvider.apiHandlerRebuild.spec.ts | 39 +- .../ClineProvider.lockApiConfig.spec.ts | 11 +- .../webview/__tests__/ClineProvider.spec.ts | 1404 +---------------- .../ClineProvider.sticky-mode.spec.ts | 18 +- .../ClineProvider.sticky-profile.spec.ts | 13 +- src/eslint-suppressions.json | 2 +- src/extension.ts | 1 - .../__tests__/api-configuration.spec.ts | 93 +- src/extension/api.ts | 13 +- src/utils/autoImportSettings.ts | 3 +- 16 files changed, 264 insertions(+), 2229 deletions(-) diff --git a/src/__tests__/extension.spec.ts b/src/__tests__/extension.spec.ts index d4252dc08f..abcd3c28a0 100644 --- a/src/__tests__/extension.spec.ts +++ b/src/__tests__/extension.spec.ts @@ -202,7 +202,6 @@ vi.mock("../core/webview/ClineProvider", async () => { contextProxy: { getGlobalState: vi.fn() }, customModesManager: {}, upsertProviderProfile: vi.fn().mockResolvedValue(undefined), - adoptModeConfigIds: vi.fn(), } return { ClineProvider: Object.assign( @@ -246,21 +245,6 @@ describe("extension.ts", () => { settingsUpdatedHandler = undefined }) - test("adopts mode profile mappings from the activation auto-import callback", async () => { - const { activate } = await import("../extension") - const { autoImportSettings } = await import("../utils/autoImportSettings") - const { ClineProvider } = await import("../core/webview/ClineProvider") - const ids = { code: "imported-id" } - vi.mocked(autoImportSettings).mockImplementationOnce(async (_output, options) => { - expect(options.onModeConfigIdsImported).toBeTypeOf("function") - options.onModeConfigIdsImported?.(ids) - }) - - await activate(mockContext) - - expect(ClineProvider.getVisibleInstance()!.adoptModeConfigIds).toHaveBeenCalledExactlyOnceWith(ids) - }) - test("shares the extension-owned focus tracker with the sidebar and code actions and disposes its listeners", async () => { vi.resetModules() const { WebviewFocusTracker } = await import("../core/webview/WebviewFocusTracker") diff --git a/src/core/config/ProviderSettingsManager.ts b/src/core/config/ProviderSettingsManager.ts index de4f229a72..a355b2ff01 100644 --- a/src/core/config/ProviderSettingsManager.ts +++ b/src/core/config/ProviderSettingsManager.ts @@ -416,18 +416,10 @@ export class ProviderSettingsManager { * Preserves the ID from the input 'config' object if it exists, * otherwise generates a new one (for creation scenarios). */ - public async saveConfig( - name: string, - config: ProviderSettingsWithId, - signal?: AbortSignal, - onPersisting?: () => void, - ): Promise { - signal?.throwIfAborted() + public async saveConfig(name: string, config: ProviderSettingsWithId): Promise { try { return await this.lock(async () => { - signal?.throwIfAborted() const providerProfiles = await this.load() - signal?.throwIfAborted() // Preserve the existing ID if this is an update to an existing config. const existingId = providerProfiles.apiConfigs[name]?.id const id = config.id || existingId || this.generateId() @@ -443,7 +435,6 @@ export class ProviderSettingsManager { ? providerSettingsWithIdSchema.passthrough().parse(normalizedConfig) : discriminatedProviderSettingsWithIdSchema.parse(normalizedConfig) providerProfiles.apiConfigs[name] = { ...filteredConfig, id } - onPersisting?.() await this.store(providerProfiles) return id }) @@ -496,20 +487,13 @@ export class ProviderSettingsManager { */ public async activateProfile( params: { name: string } | { id: string }, - signal?: AbortSignal, - onPersisting?: () => void, ): Promise { - signal?.throwIfAborted() const { name, ...providerSettings } = await this.getProfile(params) - signal?.throwIfAborted() try { return await this.lock(async () => { - signal?.throwIfAborted() const providerProfiles = await this.load() - signal?.throwIfAborted() providerProfiles.currentApiConfigName = name - onPersisting?.() await this.store(providerProfiles) return { name, ...providerSettings } }) @@ -559,12 +543,10 @@ export class ProviderSettingsManager { /** * Set the API config for a specific mode. */ - public async setModeConfig(mode: Mode, configId: string, onPersisted?: () => void, signal?: AbortSignal) { + public async setModeConfig(mode: Mode, configId: string) { try { return await this.lock(async () => { - signal?.throwIfAborted() const providerProfiles = await this.load() - signal?.throwIfAborted() // Ensure the per-mode config map exists if (!providerProfiles.modeApiConfigs) { providerProfiles.modeApiConfigs = {} @@ -572,7 +554,6 @@ export class ProviderSettingsManager { // Assign the chosen config ID to this mode providerProfiles.modeApiConfigs[mode] = configId await this.store(providerProfiles) - onPersisted?.() }) } catch (error) { throw new Error(`Failed to set mode config: ${error}`) @@ -670,13 +651,9 @@ export class ProviderSettingsManager { } } - public async import(providerProfiles: ProviderProfiles, onPersisted?: () => void) { + public async import(providerProfiles: ProviderProfiles) { try { - return await this.lock(async () => { - await this.store(providerProfiles) - // Publish local choices before a later writer can acquire the storage lock. - onPersisted?.() - }) + return await this.lock(() => this.store(providerProfiles)) } catch (error) { throw new Error(`Failed to import provider profiles: ${error}`) } diff --git a/src/core/config/__tests__/ProviderSettingsManager.spec.ts b/src/core/config/__tests__/ProviderSettingsManager.spec.ts index 401c19d0da..c77464f9f2 100644 --- a/src/core/config/__tests__/ProviderSettingsManager.spec.ts +++ b/src/core/config/__tests__/ProviderSettingsManager.spec.ts @@ -89,231 +89,6 @@ describe("ProviderSettingsManager", () => { providerSettingsManager = new ProviderSettingsManager(mockContext) }) - it.each([ - { operation: "import", fails: false }, - { operation: "import", fails: true }, - { operation: "mode write", fails: false }, - { operation: "mode write", fails: true }, - ])("publishes $operation choices only after persistence (failure: $fails)", async ({ operation, fails }) => { - let release = () => {} - const pending = new Promise((resolve) => { - release = resolve - }) - mockSecrets.store.mockImplementationOnce(async () => { - await pending - if (fails) throw new Error("write failed") - }) - const published = vi.fn() - const write = - operation === "import" - ? providerSettingsManager.import( - { currentApiConfigName: "default", apiConfigs: {}, modeApiConfigs: { code: "imported-id" } }, - published, - ) - : providerSettingsManager.setModeConfig("code", "chosen-id", published) - await vi.waitFor(() => expect(mockSecrets.store).toHaveBeenCalledOnce()) - expect(published).not.toHaveBeenCalled() - const result = fails ? expect(write).rejects.toThrow("write failed") : expect(write).resolves.toBeUndefined() - release() - await result - expect(published).toHaveBeenCalledTimes(fails ? 0 : 1) - }) - - it.each(["lock", "load"] as const)( - "checks save cancellation during %s before announcing a commit", - async (stage) => { - await providerSettingsManager.getModeConfigIds() - mockSecrets.get.mockClear() - mockSecrets.store.mockClear() - let release = () => {} - const pending = new Promise((resolve) => { - release = resolve - }) - const entered = vi.fn() - let locked = Promise.resolve() - if (stage === "lock") { - locked = providerSettingsManager["lock"](async () => { - entered() - await pending - }) - } else { - mockSecrets.get.mockImplementationOnce(async () => { - entered() - await pending - return null - }) - } - const controller = new AbortController() - const committing = vi.fn() - const saved = providerSettingsManager.saveConfig("selected", {}, controller.signal, committing) - const result = expect(saved).rejects.toMatchObject({ - name: "Error", - message: "Failed to save config: AbortError: This operation was aborted", - }) - await vi.waitFor(() => expect(entered).toHaveBeenCalledOnce()) - controller.abort() - release() - await Promise.all([locked, result]) - expect(mockSecrets.get).toHaveBeenCalledTimes(stage === "lock" ? 0 : 1) - expect(mockSecrets.store).not.toHaveBeenCalled() - expect(committing).not.toHaveBeenCalled() - }, - ) - - it.each([false, true])("checks cancellation after waiting for the storage lock (cancelled: %s)", async (cancel) => { - let release = () => {} - const pending = new Promise((resolve) => { - release = resolve - }) - mockSecrets.store.mockImplementationOnce(async () => { - await pending - }) - const imported = providerSettingsManager.import({ - currentApiConfigName: "default", - apiConfigs: {}, - modeApiConfigs: {}, - }) - await vi.waitFor(() => expect(mockSecrets.store).toHaveBeenCalledOnce()) - // Exclude the constructor's initialization read from the selected write's read count. - mockSecrets.get.mockClear() - const controller = new AbortController() - const published = vi.fn() - const selected = providerSettingsManager.setModeConfig("code", "selected-id", published, controller.signal) - if (cancel) controller.abort() - release() - const result = cancel - ? expect(selected).rejects.toMatchObject({ - name: "Error", - message: "Failed to set mode config: AbortError: This operation was aborted", - }) - : expect(selected).resolves.toBeUndefined() - await Promise.all([imported, result]) - - expect(mockSecrets.get).toHaveBeenCalledTimes(cancel ? 0 : 1) - expect(mockSecrets.store).toHaveBeenCalledTimes(cancel ? 1 : 2) - expect(published).toHaveBeenCalledTimes(cancel ? 0 : 1) - }) - - it.each([false, true])("checks cancellation after loading profiles (cancelled: %s)", async (cancel) => { - // Drain constructor initialization so the delayed read belongs to this operation. - await providerSettingsManager.getModeConfigIds() - mockSecrets.get.mockClear() - let release = () => {} - const pending = new Promise((resolve) => { - release = resolve - }) - mockSecrets.get.mockImplementationOnce(async () => { - await pending - return null - }) - const controller = new AbortController() - const published = vi.fn() - const selected = providerSettingsManager.setModeConfig("code", "selected-id", published, controller.signal) - await vi.waitFor(() => expect(mockSecrets.get).toHaveBeenCalledOnce()) - if (cancel) controller.abort() - const result = cancel - ? expect(selected).rejects.toMatchObject({ - name: "Error", - message: "Failed to set mode config: AbortError: This operation was aborted", - }) - : expect(selected).resolves.toBeUndefined() - release() - await result - - expect(mockSecrets.store).toHaveBeenCalledTimes(cancel ? 0 : 1) - expect(published).toHaveBeenCalledTimes(cancel ? 0 : 1) - }) - - it.each([false, true])("cancels profile activation waiting for storage (cancelled: %s)", async (cancel) => { - let release = () => {} - const pending = new Promise((resolve) => { - release = resolve - }) - mockSecrets.store.mockImplementationOnce(async () => { - await pending - }) - const imported = providerSettingsManager.import({ - currentApiConfigName: "default", - apiConfigs: {}, - modeApiConfigs: {}, - }) - await vi.waitFor(() => expect(mockSecrets.store).toHaveBeenCalledOnce()) - mockSecrets.get.mockClear() - const profile = vi - .spyOn(providerSettingsManager, "getProfile") - .mockResolvedValue({ name: "selected", id: "selected-id" }) - const controller = new AbortController() - const onPersisting = vi.fn() - const selected = providerSettingsManager.activateProfile({ name: "selected" }, controller.signal, onPersisting) - // Resume past getProfile while the import still holds the storage lock. - await profile.mock.results[0].value - if (cancel) controller.abort() - const result = cancel - ? expect(selected).rejects.toMatchObject({ - name: "Error", - message: "Failed to activate profile: This operation was aborted", - }) - : expect(selected).resolves.toMatchObject({ name: "selected", id: "selected-id" }) - release() - await Promise.all([imported, result]) - - expect(mockSecrets.get).toHaveBeenCalledTimes(cancel ? 0 : 1) - expect(mockSecrets.store).toHaveBeenCalledTimes(cancel ? 1 : 2) - expect(onPersisting).toHaveBeenCalledTimes(cancel ? 0 : 1) - }) - - it.each([false, true])("cancels activation during the locked profile load (cancelled: %s)", async (cancel) => { - // Drain constructor initialization so the delayed read belongs to this operation. - await providerSettingsManager.getModeConfigIds() - mockSecrets.get.mockClear() - vi.spyOn(providerSettingsManager, "getProfile").mockResolvedValue({ name: "selected", id: "selected-id" }) - let release = () => {} - const pending = new Promise((resolve) => { - release = resolve - }) - mockSecrets.get.mockImplementationOnce(async () => { - await pending - return null - }) - const controller = new AbortController() - const onPersisting = vi.fn() - const selected = providerSettingsManager.activateProfile({ name: "selected" }, controller.signal, onPersisting) - await vi.waitFor(() => expect(mockSecrets.get).toHaveBeenCalledOnce()) - if (cancel) controller.abort() - const result = cancel - ? expect(selected).rejects.toMatchObject({ - name: "Error", - message: "Failed to activate profile: This operation was aborted", - }) - : expect(selected).resolves.toMatchObject({ name: "selected", id: "selected-id" }) - release() - await result - - expect(mockSecrets.store).toHaveBeenCalledTimes(cancel ? 0 : 1) - expect(onPersisting).toHaveBeenCalledTimes(cancel ? 0 : 1) - }) - - it("announces the activation commit boundary before an uninterruptible storage write", async () => { - await providerSettingsManager.getModeConfigIds() - vi.spyOn(providerSettingsManager, "getProfile").mockResolvedValue({ name: "selected", id: "selected-id" }) - let release = () => {} - const pending = new Promise((resolve) => { - release = resolve - }) - mockSecrets.store.mockImplementationOnce(async () => { - await pending - }) - const controller = new AbortController() - const onPersisting = vi.fn() - const selected = providerSettingsManager.activateProfile({ name: "selected" }, controller.signal, onPersisting) - await vi.waitFor(() => expect(mockSecrets.store).toHaveBeenCalledOnce()) - expect(onPersisting).toHaveBeenCalledOnce() - controller.abort() - release() - - await expect(selected).resolves.toMatchObject({ name: "selected", id: "selected-id" }) - }) - describe("initialize", () => { it("should not write to storage when secrets.get returns null", async () => { // Mock readConfig to return null diff --git a/src/core/config/__tests__/importExport.spec.ts b/src/core/config/__tests__/importExport.spec.ts index 2e840b7ab2..6c66655325 100644 --- a/src/core/config/__tests__/importExport.spec.ts +++ b/src/core/config/__tests__/importExport.spec.ts @@ -187,38 +187,13 @@ describe("importExport", () => { beforeEach(() => { ;(fs.readFile as Mock).mockResolvedValue(validFileContent) mockProviderSettingsManager.export.mockResolvedValue(previousProviderProfiles) - mockProviderSettingsManager.import.mockImplementation(async (_profiles, onPersisted) => { - onPersisted?.() - }) + mockProviderSettingsManager.import.mockResolvedValue(undefined) mockProviderSettingsManager.listConfig.mockResolvedValue(profileMetadata) mockContextProxy.setValues.mockResolvedValue(undefined) mockContextProxy.setValue.mockResolvedValue(undefined) mockContextProxy.setProviderSettings.mockResolvedValue(undefined) }) - it.each([false, true])( - "updates the importing window only after successful persistence (failure: %s)", - async (fails) => { - const modeApiConfigs = { "new-custom-mode": "test-id" } - const file = JSON.parse(validFileContent) - file.providerProfiles.modeApiConfigs = modeApiConfigs - vi.mocked(fs.readFile).mockResolvedValue(JSON.stringify(file)) - const onModeConfigIdsImported = vi.fn() - if (fails) mockProviderSettingsManager.import.mockRejectedValueOnce(new Error("write failed")) - - const result = await importSettingsFromPath("/mock/path/settings.json", { - providerSettingsManager: mockProviderSettingsManager, - contextProxy: mockContextProxy, - customModesManager: mockCustomModesManager, - onModeConfigIdsImported, - }) - - expect(result.success).toBe(!fails) - if (fails) expect(onModeConfigIdsImported).not.toHaveBeenCalled() - else expect(onModeConfigIdsImported).toHaveBeenCalledExactlyOnceWith(modeApiConfigs) - }, - ) - it("waits for each provider-state write before reporting success", async () => { const currentProfileWrite = createDeferred() const providerSettingsWrite = createDeferred() @@ -663,7 +638,6 @@ describe("importExport", () => { // Create a mock provider for the test const mockProvider = { settingsImportedAt: 0, - adoptModeConfigIds: vi.fn(), postStateToWebview: vi.fn().mockResolvedValue(undefined), postStateToWebviewWithoutTaskHistory: vi.fn().mockResolvedValue(undefined), } @@ -947,7 +921,6 @@ describe("importExport", () => { const seenImportedAt: Array = [] const mockProvider = { settingsImportedAt: undefined as number | undefined, - adoptModeConfigIds: vi.fn(), postStateToWebview: vi.fn().mockImplementation(async () => { seenImportedAt.push(mockProvider.settingsImportedAt) }), @@ -1024,7 +997,6 @@ describe("importExport", () => { const seenImportedAt: Array = [] const mockProvider = { settingsImportedAt: undefined as number | undefined, - adoptModeConfigIds: vi.fn(), postStateToWebview: vi.fn().mockImplementation(async () => { seenImportedAt.push(mockProvider.settingsImportedAt) }), @@ -1296,7 +1268,6 @@ describe("importExport", () => { const mockProvider = { settingsImportedAt: 0, - adoptModeConfigIds: vi.fn(), postStateToWebview: vi.fn().mockResolvedValue(undefined), } @@ -1566,7 +1537,6 @@ describe("importExport", () => { const mockProvider = { settingsImportedAt: 0, - adoptModeConfigIds: vi.fn(), postStateToWebview: vi.fn().mockResolvedValue(undefined), } diff --git a/src/core/config/importExport.ts b/src/core/config/importExport.ts index 0dca4c1a58..9882039ad3 100644 --- a/src/core/config/importExport.ts +++ b/src/core/config/importExport.ts @@ -27,7 +27,6 @@ export type ImportOptions = { providerSettingsManager: ProviderSettingsManager contextProxy: ContextProxy customModesManager: CustomModesManager - onModeConfigIdsImported?: (ids: Record) => void } type ExportOptions = { @@ -38,7 +37,6 @@ type ImportWithProviderOptions = ImportOptions & { provider: { settingsImportedAt?: number postStateToWebview: () => Promise - adoptModeConfigIds: (ids: Record) => void } } @@ -137,7 +135,7 @@ function sanitizeGlobalSettings(rawGlobalSettings: unknown): { */ export async function importSettingsFromPath( filePath: string, - { providerSettingsManager, contextProxy, customModesManager, onModeConfigIdsImported }: ImportOptions, + { providerSettingsManager, contextProxy, customModesManager }: ImportOptions, ) { // Use a lenient schema that accepts any apiConfigs, then validate each individually const lenientProviderProfilesSchema = providerProfilesSchema.extend({ @@ -229,13 +227,7 @@ export async function importSettingsFromPath( // OpenAI Compatible settings are now correctly stored in codebaseIndexConfig // They will be imported automatically with the config - no special handling needed - if (onModeConfigIdsImported) { - await providerSettingsManager.import(providerProfiles, () => - onModeConfigIdsImported(rawProviderProfiles.modeApiConfigs ?? {}), - ) - } else { - await providerSettingsManager.import(providerProfiles) - } + await providerSettingsManager.import(providerProfiles) await contextProxy.setValues(sanitizedGlobalSettings) // Set the current provider. @@ -277,12 +269,7 @@ export async function importSettingsFromPath( * @param options - Import options containing managers and proxy * @returns Promise resolving to import result */ -export const importSettings = async ({ - providerSettingsManager, - contextProxy, - customModesManager, - onModeConfigIdsImported, -}: ImportOptions) => { +export const importSettings = async ({ providerSettingsManager, contextProxy, customModesManager }: ImportOptions) => { // Use the last export path as a sensible default, falling back to Downloads const defaultUri = resolveDefaultSaveUri(contextProxy, "lastSettingsExportPath", "zoo-code-settings.json", { useWorkspace: false, @@ -303,7 +290,6 @@ export const importSettings = async ({ providerSettingsManager, contextProxy, customModesManager, - onModeConfigIdsImported, }) } @@ -316,14 +302,13 @@ export const importSettings = async ({ * @returns Promise resolving to import result */ export const importSettingsFromFile = async ( - { providerSettingsManager, contextProxy, customModesManager, onModeConfigIdsImported }: ImportOptions, + { providerSettingsManager, contextProxy, customModesManager }: ImportOptions, fileUri: vscode.Uri, ) => { return importSettingsFromPath(fileUri.fsPath, { providerSettingsManager, contextProxy, customModesManager, - onModeConfigIdsImported, }) } @@ -389,7 +374,6 @@ export const importSettingsWithFeedback = async ( providerSettingsManager, contextProxy, customModesManager, - onModeConfigIdsImported: (ids) => provider.adoptModeConfigIds(ids), }) } catch (error) { result = { @@ -398,12 +382,7 @@ export const importSettingsWithFeedback = async ( } } } else { - result = await importSettings({ - providerSettingsManager, - contextProxy, - customModesManager, - onModeConfigIdsImported: (ids) => provider.adoptModeConfigIds(ids), - }) + result = await importSettings({ providerSettingsManager, contextProxy, customModesManager }) } if (result.success) { diff --git a/src/core/webview/ClineProvider.ts b/src/core/webview/ClineProvider.ts index d902a4d4aa..16d4d0aca0 100644 --- a/src/core/webview/ClineProvider.ts +++ b/src/core/webview/ClineProvider.ts @@ -329,14 +329,7 @@ export class ClineProvider public readonly taskHistoryStore: TaskHistoryStore private taskHistoryStoreInitialized = false public static readonly PENDING_OPERATION_TIMEOUT_MS = 30000 // 30 seconds - private readonly profileMutationAbortController = new AbortController() - private get providerProfileMutationQueue() { - return this.modeProfileState.profileMutationQueue - } - - private set providerProfileMutationQueue(queue: Promise) { - this.modeProfileState.profileMutationQueue = queue - } + private providerProfileMutationQueue = Promise.resolve() private historyTaskCreationQueue = Promise.resolve() private runDelegationTransition(parentTaskId: string, fn: () => Promise): Promise { @@ -352,103 +345,61 @@ export class ClineProvider fn: (signal: AbortSignal) => Promise, options: { runToCompletion?: boolean } = {}, ): Promise { - if (this.modeProfileState.reset) { - return Promise.reject(new Error("Provider profile mutation cancelled by settings reset")) - } const controller = new AbortController() - let timedOut = false - const signal = AbortSignal.any([controller.signal, this.profileMutationAbortController.signal]) - const invoke = async () => { - signal.throwIfAborted() - if (this.modeProfileState.reset) throw new Error("Provider profile mutation cancelled by settings reset") - this.modeProfileState.activeMutationSignals.add(signal) - try { - return await fn(signal) - } finally { - this.modeProfileState.activeMutationSignals.delete(signal) - } - } // Run fn after either outcome so a rejected mutation never poisons the queue. - const previous = this.providerProfileMutationQueue - const run = previous.then(invoke, invoke) - this.modeProfileState.mutations.add(run) - const callerResult = this.withProviderProfileMutationTimeout( - run, - () => { - timedOut = true - if (options.runToCompletion || this.modeProfileState.committingMutationSignals.has(signal)) { - this.log("Provider profile mutation timed out; waiting for it to finish before the next mutation") - return - } - - controller.abort() - this.log("Provider profile mutation timed out; aborting in-flight mutation") - }, - this.profileMutationAbortController.signal, - signal, + const run = this.providerProfileMutationQueue.then( + () => fn(controller.signal), + () => fn(controller.signal), ) + const callerResult = this.withProviderProfileMutationTimeout(run, () => { + if (options.runToCompletion) { + this.log("Provider profile mutation timed out; waiting for it to finish before the next mutation") + return + } + + controller.abort() + this.log("Provider profile mutation timed out; aborting in-flight mutation") + }) void run.then( () => { - this.modeProfileState.mutations.delete(run) - this.modeProfileState.committingMutationSignals.delete(signal) - if (signal.aborted) { + if (controller.signal.aborted) { this.log("Provider profile mutation completed after cancellation") } }, - () => { - this.modeProfileState.mutations.delete(run) - this.modeProfileState.committingMutationSignals.delete(signal) - if (signal.aborted || timedOut) { + (error) => { + if (controller.signal.aborted) { this.log( - "Provider profile mutation failed after cancellation or timeout; settings may be partially persisted", + `Provider profile mutation errored after cancellation: ${ + error instanceof Error ? error.message : String(error) + }`, ) } }, ) - // A cancelled read may release the queue, but a started commit must finish before any tab writes again. - this.providerProfileMutationQueue = callerResult.then( + // Advance from the timeout-bounded result. Each fn checks its AbortSignal before + // writing state, so advancing the queue on timeout cannot produce stale overwrites. + this.providerProfileMutationQueue = (options.runToCompletion ? run : callerResult).then( + () => undefined, () => undefined, - async () => { - if (options.runToCompletion) { - await run.catch(() => {}) - } else { - // Cancelling a queued item must not bypass an earlier committing mutation. - await previous.catch(() => {}) - } - }, ) return callerResult } - private withProviderProfileMutationTimeout( - operation: Promise, - onTimeout: () => void, - signal: AbortSignal, - mutationSignal: AbortSignal, - ): Promise { + private withProviderProfileMutationTimeout(operation: Promise, onTimeout: () => void): Promise { let timeoutId: ReturnType | undefined const timeout = new Promise((_, reject) => { timeoutId = setTimeout(() => { onTimeout() - if (!this.modeProfileState.committingMutationSignals.has(mutationSignal)) { - reject(new Error("Provider profile mutation timed out")) - } + reject(new Error("Provider profile mutation timed out")) }, ClineProvider.PENDING_OPERATION_TIMEOUT_MS) }) - let onAbort = () => {} - const cancelled = new Promise((_, reject) => { - onAbort = () => { - if (!this.modeProfileState.committingMutationSignals.has(mutationSignal)) reject(signal.reason) - } - if (signal.aborted) onAbort() - else signal.addEventListener("abort", onAbort, { once: true }) - }) - return Promise.race([operation, timeout, cancelled]).finally(() => { - if (timeoutId) clearTimeout(timeoutId) - signal.removeEventListener("abort", onAbort) + return Promise.race([operation, timeout]).finally(() => { + if (timeoutId) { + clearTimeout(timeoutId) + } }) } @@ -474,46 +425,15 @@ export class ClineProvider * Mode -> profile id choices made by this window. The persisted mode map in * `providerSettingsManager` is shared by every VS Code window, so reading it * alone lets another window's profile selection leak into this window's tasks. - * The window's focus tracker is shared by sidebar and tab providers, so it keys their shared choices. */ - private static readonly modeProfilesByWindow = new WeakMap< - WebviewFocusTracker, - { state: ClineProvider["modeProfileState"]; manager: ProviderSettingsManager } - >() - - private modeProfileState = { - localIds: new Map(), - writeOwners: new Map(), - writes: new Map>(), - mutations: new Set>(), - profileMutationQueue: Promise.resolve(), - activeMutationSignals: new Set(), - committingMutationSignals: new Set(), - reset: undefined as Promise | undefined, - // Capture the shared map once when the window opens; late tabs reuse that snapshot. - // Undefined means the opening snapshot failed, rather than an empty mapping. - initialIds: Promise.resolve | undefined>({}), - } - - private get localModeConfigIds() { - return this.modeProfileState.localIds - } - - private get modeConfigWriteOwners() { - return this.modeProfileState.writeOwners - } - - private get modeConfigWrites() { - return this.modeProfileState.writes - } + private readonly localModeConfigIds = new Map() - private get initialModeConfigIds() { - return this.modeProfileState.initialIds - } - - private set initialModeConfigIds(ids: Promise | undefined>) { - this.modeProfileState.initialIds = ids - } + /** + * The shared mode map as it was when this window opened. Modes this window has not changed + * resolve against it, so another window's later selection cannot reach this window's tasks + * (including delegated subtasks). + */ + private initialModeConfigIds: Promise> = Promise.resolve({}) constructor( readonly context: vscode.ExtensionContext, @@ -551,18 +471,8 @@ export class ClineProvider this._workspaceTracker = new WorkspaceTracker(this) - const windowModeProfiles = ClineProvider.modeProfilesByWindow.get(webviewFocusTracker) - if (windowModeProfiles) { - this.modeProfileState = windowModeProfiles.state - this.providerSettingsManager = windowModeProfiles.manager - } else { - this.providerSettingsManager = new ProviderSettingsManager(this.context) - ClineProvider.modeProfilesByWindow.set(webviewFocusTracker, { - state: this.modeProfileState, - manager: this.providerSettingsManager, - }) - this.captureInitialModeConfigIds() - } + this.providerSettingsManager = new ProviderSettingsManager(this.context) + this.captureInitialModeConfigIds() this.customModesManager = new CustomModesManager(this.context, async () => { await this.postStateToWebviewWithoutClineMessages() @@ -1056,7 +966,6 @@ export class ClineProvider } this._disposed = true - this.profileMutationAbortController.abort(new Error("Provider disposed")) this._postStateToWebviewThrottled.cancel() this.stopWebviewWatchdog() this.diagnosticsRecorder.record({ boundary: "provider", phase: "start", type: "dispose" }) @@ -2160,169 +2069,123 @@ export class ClineProvider targetTask: Task | null | undefined, signal?: AbortSignal, ): Promise { - if (signal?.aborted) return + const task = targetTask + + if (task) { + TelemetryService.instance.captureModeSwitch(task.taskId, newMode) + task.emit(RooCodeEventName.TaskModeSwitched, task.taskId, newMode) + + try { + // Update the task history with the new mode first. + const taskHistoryItem = this.getTaskHistoryItem(task.taskId) + + if (taskHistoryItem) { + await this.updateTaskHistory({ ...taskHistoryItem, mode: newMode }) + } + + // Only update the task's mode after successful persistence. + ;(task as any)._taskMode = newMode + } catch (error) { + // If persistence fails, log the error but don't update the in-memory state. + this.log( + `Failed to persist mode switch for task ${task.taskId}: ${error instanceof Error ? error.message : String(error)}`, + ) + + // Optionally, we could emit an event to notify about the failure. + // This ensures the in-memory state remains consistent with persisted state. + throw error + } + } + + await this.updateGlobalState("mode", newMode) + + this.emit(RooCodeEventName.ModeChanged, newMode) + + // If workspace lock is on, keep the current API config — don't load mode-specific config const lockApiConfigAcrossModes = this.context.workspaceState.get("lockApiConfigAcrossModes", false) - let profiles: ProviderSettingsEntry[] | undefined - let profileName: string | undefined - // Resolve the choice before any writes so cancellation during a read leaves no partial switch. - if (!lockApiConfigAcrossModes) { - const id = await this.getModeConfigId(newMode, signal) - if (signal?.aborted) return - profiles = await this.providerSettingsManager.listConfig() - if (signal?.aborted) return - const profile = profiles.find((entry) => entry.id === id) - if (profile) { - const settings = await this.providerSettingsManager.getProfile({ name: profile.name }) - if (signal?.aborted) return - // Empty CLI profiles must not replace working runtime settings. - if (settings.apiProvider) profileName = profile.name + if (lockApiConfigAcrossModes) { + if (targetTask !== null) { + await this.postStateToWebview() } + return } if (signal?.aborted) return - if (signal) this.modeProfileState.committingMutationSignals.add(signal) - try { - if (targetTask) { - TelemetryService.instance.captureModeSwitch(targetTask.taskId, newMode) - targetTask.emit(RooCodeEventName.TaskModeSwitched, targetTask.taskId, newMode) - const history = this.getTaskHistoryItem(targetTask.taskId) - if (history) { - // Persist the mode and sticky profile together for consistent restoration after disposal. - await this.updateTaskHistory({ - ...history, - mode: newMode, - ...(profileName ? { apiConfigName: profileName } : {}), - }) + + // Load the saved API config for the new mode if it exists. + const savedConfigId = await this.getModeConfigId(newMode) + const listApiConfig = await this.providerSettingsManager.listConfig() + + if (signal?.aborted) return + + // Update listApiConfigMeta first to ensure UI has latest data. + await this.updateGlobalState("listApiConfigMeta", listApiConfig) + + // If this mode has a saved config, use it. + if (savedConfigId) { + const profile = listApiConfig.find(({ id }) => id === savedConfigId) + + if (profile?.name) { + // Check if the profile has actual API configuration (not just an id). + // In CLI mode, the ProviderSettingsManager may return empty default profiles + // that only contain 'id' and 'name' fields. Activating such a profile would + // overwrite the CLI's working API configuration with empty settings. + // Skip activation if the profile has no apiProvider set - this indicates + // an unconfigured/empty profile. + const fullProfile = await this.providerSettingsManager.getProfile({ name: profile.name }) + const hasActualSettings = !!fullProfile.apiProvider + + if (hasActualSettings) { + await this.activateProviderProfileUnlocked( + { name: profile.name }, + targetTask === null ? { skipCurrentTaskRebuild: true } : undefined, + signal, + ) + } else { + // The task will continue with the current/default configuration. } - targetTask["_taskMode"] = newMode - if (profileName) targetTask.setTaskApiConfigName(profileName) + } else { + // The task will continue with the current/default configuration. } - // Once a write starts, drain the whole persistence sequence before another tab can write. - await this.updateGlobalState("mode", newMode) - if (profiles) await this.updateGlobalState("listApiConfigMeta", profiles) - if (profileName) { - await this.activateProviderProfileUnlocked( - { name: profileName }, - { - persistModeConfig: false, - persistTaskHistory: false, - skipCurrentTaskRebuild: targetTask === null, - }, - signal, - ) + } else { + // If no saved config for this mode, save current config as default. + const currentApiConfigNameAfter = this.getGlobalState("currentApiConfigName") + + if (currentApiConfigNameAfter) { + const config = listApiConfig.find((c) => c.name === currentApiConfigNameAfter) + + if (config?.id) { + await this.setModeConfig(newMode, config.id) + } } - } catch (error) { - throw new Error( - `Mode switch may be partially persisted: ${error instanceof Error ? error.message : String(error)}`, - { cause: error }, - ) } - if (signal?.aborted) return - this.emit(RooCodeEventName.ModeChanged, newMode) - if (targetTask !== null) await this.postStateToWebview() + + if (targetTask !== null) { + await this.postStateToWebview() + } } // Provider Profile Management private captureInitialModeConfigIds(): void { - this.initialModeConfigIds = this.providerSettingsManager.getModeConfigIds().catch(() => { - this.log("Failed to snapshot mode profile choices") - return undefined + this.initialModeConfigIds = this.providerSettingsManager.getModeConfigIds().catch((error) => { + this.log(`Failed to snapshot mode profile choices: ${error instanceof Error ? error.message : error}`) + return {} }) } - /** - * Resolve the profile id for `mode` from this window's own view: its explicit choices, then the - * shared map as it was when the window opened. Modes absent from both resolve to `undefined`, so - * callers keep this window's current profile instead of one another window saved later. A cached - * id whose profile no longer exists (e.g. after a reset) is dropped in favour of the shared map, - * while an unreadable opening snapshot keeps this window’s current profile. - */ - private async getModeConfigId(mode: Mode, signal?: AbortSignal): Promise { - if (signal?.aborted) return undefined - const localId = this.localModeConfigIds.get(mode) - const initialIds = localId === undefined ? await this.initialModeConfigIds : undefined - if (signal?.aborted) return undefined - if (this.localModeConfigIds.get(mode) !== localId) return this.getModeConfigId(mode, signal) - const cachedId = localId ?? initialIds?.[mode] - if (cachedId === undefined) return undefined - - const profiles = await this.providerSettingsManager.listConfig() - if (signal?.aborted) return undefined - // A profile selection may have changed while either asynchronous read was pending. - if (this.localModeConfigIds.get(mode) !== localId) return this.getModeConfigId(mode, signal) - if (profiles.some(({ id }) => id === cachedId)) return cachedId - - if (localId !== undefined) this.localModeConfigIds.delete(mode) - return this.providerSettingsManager.getModeConfigId(mode) - } - - /** Adopt imported mappings from the manager's persistence callback, while its storage lock is held. */ - public adoptModeConfigIds(ids: Record): void { - for (const [mode, id] of Object.entries(ids)) { - this.localModeConfigIds.set(mode, id) - this.modeConfigWriteOwners.delete(mode) - } - } - - public async setModeConfig(mode: Mode, id: string, signal?: AbortSignal): Promise { - // An activation that reset is draining must finish all its writes before deletion. - const committing = signal !== undefined && this.modeProfileState.committingMutationSignals.has(signal) - const completingMutation = - committing || (signal !== undefined && this.modeProfileState.activeMutationSignals.has(signal)) - const writeSignal = committing - ? new AbortController().signal - : signal - ? AbortSignal.any([signal, this.profileMutationAbortController.signal]) - : this.profileMutationAbortController.signal - writeSignal.throwIfAborted() - if (this.modeProfileState.reset && !completingMutation) - throw new Error("Mode profile write cancelled by settings reset") - const pending = this.modeConfigWrites.get(mode) - const write = (async () => { - // A failed predecessor must roll back before this operation captures its previous choice. - if (pending) await pending.catch(() => {}) - // Reset invalidates queued selections before their profiles are deleted. - writeSignal.throwIfAborted() - if (this.modeProfileState.reset && !completingMutation) - throw new Error("Mode profile write cancelled by settings reset") - await this.writeModeConfig(mode, id, writeSignal) - })() - this.modeConfigWrites.set(mode, write) - try { - await write - } finally { - if (this.modeConfigWrites.get(mode) === write) this.modeConfigWrites.delete(mode) - } + private async getModeConfigId(mode: Mode): Promise { + return ( + this.localModeConfigIds.get(mode) ?? + (await this.initialModeConfigIds)[mode] ?? + // Modes created after this window opened have no snapshot entry. + (await this.providerSettingsManager.getModeConfigId(mode)) + ) } - private async writeModeConfig(mode: Mode, id: string, signal?: AbortSignal): Promise { - const previousId = this.localModeConfigIds.get(mode) - const owner = Symbol() - this.modeConfigWriteOwners.set(mode, owner) + private async setModeConfig(mode: Mode, id: string): Promise { this.localModeConfigIds.set(mode, id) - let persisted = false - const rollback = () => { - if (this.modeConfigWriteOwners.get(mode) !== owner) return - if (previousId === undefined) this.localModeConfigIds.delete(mode) - else this.localModeConfigIds.set(mode, previousId) - } - const onPersisted = () => { - persisted = true - // An import may have adopted another choice while this write waited for the storage lock. - this.localModeConfigIds.set(mode, id) - } - try { - if (signal) await this.providerSettingsManager.setModeConfig(mode, id, onPersisted, signal) - else await this.providerSettingsManager.setModeConfig(mode, id, onPersisted) - } catch (error) { - // Only roll back our optimistic update; an import may have adopted even the same ID. - rollback() - throw error - } finally { - if (signal?.aborted && !persisted) rollback() - if (this.modeConfigWriteOwners.get(mode) === owner) this.modeConfigWriteOwners.delete(mode) - } + await this.providerSettingsManager.setModeConfig(mode, id) } /** @@ -2502,20 +2365,20 @@ export class ClineProvider activate: boolean, signal: AbortSignal, ): Promise { - signal.throwIfAborted() - const task = this.getCurrentTask() // TODO: Do we need to be calling `activateProfile`? It's not // clear to me what the source of truth should be; in some cases // we rely on the `ContextProxy`'s data store and in other cases // we rely on the `ProviderSettingsManager`'s data store. It might // be simpler to unify these two. - const id = await this.providerSettingsManager.saveConfig(name, providerSettings, signal, () => { - this.modeProfileState.committingMutationSignals.add(signal) - }) + const id = await this.providerSettingsManager.saveConfig(name, providerSettings) + + if (signal.aborted) return id if (activate) { const { mode } = await this.getState() + if (signal.aborted) return id + // These promises do the following: // 1. Adds or updates the list of provider profiles. // 2. Sets the current provider profile. @@ -2527,11 +2390,10 @@ export class ClineProvider // We should probably switch to that and verify that it works. // I left the original implementation in just to be safe. // `allSettled` so a caller that rolls back after a failure never races a write still in flight. - const profiles = await this.providerSettingsManager.listConfig() const activationResults = await Promise.allSettled([ - this.updateGlobalState("listApiConfigMeta", profiles), + this.updateGlobalState("listApiConfigMeta", await this.providerSettingsManager.listConfig()), this.updateGlobalState("currentApiConfigName", name), - this.setModeConfig(mode, id, signal), + this.setModeConfig(mode, id), this.contextProxy.setProviderSettings(providerSettings), ]) const failedActivation = activationResults.find( @@ -2539,13 +2401,15 @@ export class ClineProvider ) if (failedActivation) throw failedActivation.reason - if (task) await this.persistStickyProviderProfileToCurrentTask(name, { task, throwOnFailure: true }) if (signal.aborted) return id // Change the provider for the current task. // TODO: We should rename `buildApiHandler` for clarity (e.g. `getProviderClient`). this.updateTaskApiHandlerIfNeeded(providerSettings, { forceRebuild: true }) + + // Keep the current task's sticky provider profile in sync with the newly-activated profile. + await this.persistStickyProviderProfileToCurrentTask(name) } else { await this.updateGlobalState("listApiConfigMeta", await this.providerSettingsManager.listConfig()) } @@ -2581,15 +2445,10 @@ export class ClineProvider private async persistStickyProviderProfileToCurrentTask( apiConfigName: string, - options: { - skipCurrentTaskRebuild?: boolean - expectedCurrentTaskId?: string - task?: Task - throwOnFailure?: boolean - } = {}, + options: { skipCurrentTaskRebuild?: boolean; expectedCurrentTaskId?: string } = {}, ): Promise { if (options.skipCurrentTaskRebuild) return - const task = options.task ?? this.getCurrentTask() + const task = this.getCurrentTask() if (!task || (options.expectedCurrentTaskId && task.taskId !== options.expectedCurrentTaskId)) { return } @@ -2605,13 +2464,12 @@ export class ClineProvider await this.updateTaskHistory({ ...taskHistoryItem, apiConfigName }) } } catch (error) { - // Log failures; committed activations also propagate them as partial persistence. + // If persistence fails, log the error but don't fail the profile switch. this.log( `Failed to persist provider profile switch for task ${task.taskId}: ${ error instanceof Error ? error.message : String(error) }`, ) - if (options.throwOnFailure) throw error } } @@ -2638,79 +2496,54 @@ export class ClineProvider skipCurrentTaskRebuild?: boolean expectedCurrentTaskId?: string }, - signal: AbortSignal = this.profileMutationAbortController.signal, + signal?: AbortSignal, ): Promise { - const completingSwitch = this.modeProfileState.committingMutationSignals.has(signal) - if (!completingSwitch) signal.throwIfAborted() - const persistenceSignal = completingSwitch ? new AbortController().signal : signal - const task = this.getCurrentTask() - const stickyTask = - !options?.skipCurrentTaskRebuild && - (!options?.expectedCurrentTaskId || task?.taskId === options.expectedCurrentTaskId) - ? task - : undefined - const tracked = this.modeProfileState.activeMutationSignals.has(signal) - let persistenceStarted = false - let persistenceFinished = false - const startPersistence = () => { - persistenceStarted = true - this.modeProfileState.committingMutationSignals.add(signal) + const { name, id, ...providerSettings } = await this.providerSettingsManager.activateProfile(args) + + if (signal?.aborted) return + + const persistModeConfig = options?.persistModeConfig ?? true + const persistTaskHistory = options?.persistTaskHistory ?? true + const skipCurrentTaskRebuild = options?.skipCurrentTaskRebuild ?? false + + if (!skipCurrentTaskRebuild) { + // See `upsertProviderProfile` for a description of what this is doing. + await Promise.all([ + this.contextProxy.setValue("listApiConfigMeta", await this.providerSettingsManager.listConfig()), + this.contextProxy.setValue("currentApiConfigName", name), + this.contextProxy.setProviderSettings(providerSettings), + ]) } - try { - const { name, id, ...providerSettings } = await this.providerSettingsManager.activateProfile( - args, - persistenceSignal, - startPersistence, - ) - // Returning from activateProfile confirms that its active-profile write committed. - startPersistence() - const persistModeConfig = options?.persistModeConfig ?? true - const persistTaskHistory = options?.persistTaskHistory ?? true - const skipCurrentTaskRebuild = options?.skipCurrentTaskRebuild ?? false - - // Once the active profile write starts, finish its matching context and mode writes. - // Disposal still cancels queued activations and suppresses task/UI work below. - if (!skipCurrentTaskRebuild) { - const profiles = await this.providerSettingsManager.listConfig() - const writes = await Promise.allSettled([ - this.contextProxy.setValue("listApiConfigMeta", profiles), - this.contextProxy.setValue("currentApiConfigName", name), - this.contextProxy.setProviderSettings(providerSettings), - ]) - const failed = writes.find((result): result is PromiseRejectedResult => result.status === "rejected") - if (failed) throw failed.reason - } - const { mode } = await this.getState() - if (id && persistModeConfig) await this.setModeConfig(mode, id, signal) - if (persistTaskHistory && stickyTask) { - await this.persistStickyProviderProfileToCurrentTask(name, { task: stickyTask, throwOnFailure: true }) - } - persistenceFinished = true - if (signal.aborted) return + const { mode } = await this.getState() + + if (id && persistModeConfig) { + await this.setModeConfig(mode, id) + } + + // Change the provider for the current task. + const expectedCurrentTaskId = options?.expectedCurrentTaskId + this.updateTaskApiHandlerIfNeeded(providerSettings, { + forceRebuild: true, + skipCurrentTaskRebuild, + expectedCurrentTaskId, + }) - const expectedCurrentTaskId = options?.expectedCurrentTaskId - this.updateTaskApiHandlerIfNeeded(providerSettings, { - forceRebuild: true, + // Update the current task's sticky provider profile, unless this activation is + // being used purely as a non-persisting restoration (e.g., reopening a task from history). + if (persistTaskHistory) { + await this.persistStickyProviderProfileToCurrentTask(name, { skipCurrentTaskRebuild, expectedCurrentTaskId, }) - if (signal.aborted) return - if (!skipCurrentTaskRebuild) await this.postStateToWebview() - if (signal.aborted) return - if (providerSettings.apiProvider && !skipCurrentTaskRebuild) { - this.emit(RooCodeEventName.ProviderProfileChanged, { name, provider: providerSettings.apiProvider }) - } - } catch (error) { - if (persistenceStarted && !persistenceFinished) { - throw new Error( - `Profile activation may be partially persisted: ${error instanceof Error ? error.message : String(error)}`, - { cause: error }, - ) - } - throw error - } finally { - if (!tracked) this.modeProfileState.committingMutationSignals.delete(signal) + } + + if (!skipCurrentTaskRebuild) { + await this.postStateToWebview() + } + + if (providerSettings.apiProvider && !skipCurrentTaskRebuild) { + this.emit(RooCodeEventName.ProviderProfileChanged, { name, provider: providerSettings.apiProvider }) } } @@ -3934,21 +3767,6 @@ export class ClineProvider return } - if (this.modeProfileState.reset) return this.modeProfileState.reset - const reset = this.resetStateAfterProfileMutations() - this.modeProfileState.reset = reset - try { - await reset - } finally { - this.modeProfileState.reset = undefined - } - } - - private async resetStateAfterProfileMutations(): Promise { - // Drain whole profile mutations, including saves and context updates, before deleting state. - // The shared reset promise rejects new/queued mutations in every tab while active ones finish. - await Promise.allSettled([...this.modeProfileState.mutations, ...this.modeConfigWrites.values()]) - // Log out from cloud if authenticated if (CloudService.hasInstance()) { try { @@ -3965,7 +3783,6 @@ export class ClineProvider await this.providerSettingsManager.resetAllConfigs() // Cached choices point at profiles that no longer exist; re-read the reset mapping. this.localModeConfigIds.clear() - this.modeConfigWriteOwners.clear() this.captureInitialModeConfigIds() await this.customModesManager.resetCustomModes() await this.removeClineFromStack() diff --git a/src/core/webview/__tests__/ClineProvider.apiHandlerRebuild.spec.ts b/src/core/webview/__tests__/ClineProvider.apiHandlerRebuild.spec.ts index f7373efb0b..3d8beb72fa 100644 --- a/src/core/webview/__tests__/ClineProvider.apiHandlerRebuild.spec.ts +++ b/src/core/webview/__tests__/ClineProvider.apiHandlerRebuild.spec.ts @@ -239,7 +239,7 @@ describe("ClineProvider - API Handler Rebuild Guard", () => { new ContextProxy(mockContext), new WebviewFocusTracker(), ) - // Tests provide explicit opening snapshots when they need saved mode profiles. + // These tests stub providerSettingsManager and expect it to be consulted for mode profiles. provider["initialModeConfigIds"] = Promise.resolve({}) // Mock providerSettingsManager @@ -643,7 +643,7 @@ describe("ClineProvider - API Handler Rebuild Guard", () => { expect(vscode.window.showErrorMessage).toHaveBeenCalledWith("errors.update_profile_model_partial") }) - test("waits beyond timeout for a committing model update", async () => { + test("finishes activation after the caller timed out instead of leaving a saved but inactive profile", async () => { vi.useFakeTimers() try { @@ -664,11 +664,11 @@ describe("ClineProvider - API Handler Rebuild Guard", () => { }) await vi.advanceTimersByTimeAsync(ClineProvider.PENDING_OPERATION_TIMEOUT_MS + 1) + await update expect(provider["providerSettingsManager"].setModeConfig).not.toHaveBeenCalled() release() await vi.advanceTimersByTimeAsync(0) - await update const manager = provider["providerSettingsManager"] expect(manager.setModeConfig).toHaveBeenCalledTimes(1) @@ -680,7 +680,7 @@ describe("ClineProvider - API Handler Rebuild Guard", () => { } }) - test("upsertProviderProfile waits beyond timeout for its persistence outcome", async () => { + test("upsertProviderProfile finishes activation after the caller timed out", async () => { vi.useFakeTimers() try { @@ -696,13 +696,6 @@ describe("ClineProvider - API Handler Rebuild Guard", () => { return realGetState() }) - vi.mocked(provider.providerSettingsManager.saveConfig).mockImplementationOnce( - async (_name, _config, _signal, onPersisting) => { - onPersisting?.() - return "test-id" - }, - ) - const upsert = provider.upsertProviderProfile( "test-config", { apiProvider: providerIdentifiers.openrouter, openRouterModelId: "anthropic/claude" }, @@ -710,6 +703,7 @@ describe("ClineProvider - API Handler Rebuild Guard", () => { ) await vi.advanceTimersByTimeAsync(ClineProvider.PENDING_OPERATION_TIMEOUT_MS + 1) + await expect(upsert).resolves.toBeUndefined() const manager = provider["providerSettingsManager"] expect(manager.setModeConfig).not.toHaveBeenCalled() @@ -717,7 +711,6 @@ describe("ClineProvider - API Handler Rebuild Guard", () => { release() await vi.advanceTimersByTimeAsync(0) - await expect(upsert).resolves.toBe("test-id") expect(manager.saveConfig).toHaveBeenCalledTimes(1) expect(manager.setModeConfig).toHaveBeenCalledTimes(1) } finally { @@ -725,7 +718,7 @@ describe("ClineProvider - API Handler Rebuild Guard", () => { } }) - test("holds the next profile mutation until a committing model update settles", async () => { + test("holds the next profile mutation until a timed-out model update settles", async () => { vi.useFakeTimers() try { @@ -751,6 +744,7 @@ describe("ClineProvider - API Handler Rebuild Guard", () => { openRouterModelId: "anthropic/claude", }) await vi.advanceTimersByTimeAsync(ClineProvider.PENDING_OPERATION_TIMEOUT_MS + 1) + await update const next = provider.activateProviderProfile({ name: "other-profile" }) await vi.advanceTimersByTimeAsync(0) @@ -758,7 +752,7 @@ describe("ClineProvider - API Handler Rebuild Guard", () => { release() await vi.advanceTimersByTimeAsync(0) - await Promise.all([update, next]) + await next expect(manager.activateProfile).toHaveBeenCalledTimes(1) // One write set from the model update, one from the queued activation. @@ -888,7 +882,7 @@ describe("ClineProvider - API Handler Rebuild Guard", () => { expect(setValueSpy).toHaveBeenCalledWith("currentApiConfigName", "second-profile") }) - test("timed-out uncommitted mutations abort before writes and advance the queue", async () => { + test("timed-out mutations abort before writing state and advance the queue", async () => { vi.useFakeTimers() const logSpy = vi.spyOn(provider, "log") const setValueSpy = vi.spyOn(provider.contextProxy, "setValue") @@ -898,9 +892,8 @@ describe("ClineProvider - API Handler Rebuild Guard", () => { }) provider["providerSettingsManager"].activateProfile = vi .fn() - .mockImplementationOnce(async (_args, signal) => { + .mockImplementationOnce(async () => { await firstActivation - signal?.throwIfAborted() return { name: "first-profile", id: "first-id", @@ -921,14 +914,11 @@ describe("ClineProvider - API Handler Rebuild Guard", () => { await vi.advanceTimersByTimeAsync(ClineProvider.PENDING_OPERATION_TIMEOUT_MS) await firstResult - // An uncommitted timeout releases the queue while its cancelled storage read settles. + // Queue advanced immediately on timeout — second enqueues now. const second = provider.activateProviderProfile({ name: "second-profile" }) // activateProfile not yet called for second (it runs in the next microtask). expect(provider["providerSettingsManager"].activateProfile).toHaveBeenCalledTimes(1) - await vi.advanceTimersByTimeAsync(0) - expect(provider["providerSettingsManager"].activateProfile).toHaveBeenCalledTimes(2) - // Resolve the first activation's inner promise so its in-flight mock can return. // The aborted signal prevents it from writing any state. resolveFirst() @@ -987,7 +977,6 @@ describe("ClineProvider - API Handler Rebuild Guard", () => { }, }) await provider.addClineToStack(mockTask) - provider["initialModeConfigIds"] = Promise.resolve({ ask: "ask-id" }) provider["providerSettingsManager"].getModeConfigId = vi.fn().mockResolvedValue("ask-id") provider["providerSettingsManager"].listConfig = vi .fn() @@ -1021,11 +1010,7 @@ describe("ClineProvider - API Handler Rebuild Guard", () => { expect(setValueSpy).not.toHaveBeenCalledWith("currentApiConfigName", "ask-profile") expect(setProviderSettingsSpy).not.toHaveBeenCalled() expect(emitSpy).toHaveBeenCalledWith(RooCodeEventName.ModeChanged, "ask") - expect(provider["providerSettingsManager"].activateProfile).toHaveBeenCalledWith( - { name: "ask-profile" }, - expect.any(AbortSignal), - expect.any(Function), - ) + expect(provider["providerSettingsManager"].activateProfile).toHaveBeenCalledWith({ name: "ask-profile" }) }) test("calls updateApiConfiguration when provider/model unchanged but settings differ (explicit profile switch)", async () => { diff --git a/src/core/webview/__tests__/ClineProvider.lockApiConfig.spec.ts b/src/core/webview/__tests__/ClineProvider.lockApiConfig.spec.ts index 84c7760619..62514466cb 100644 --- a/src/core/webview/__tests__/ClineProvider.lockApiConfig.spec.ts +++ b/src/core/webview/__tests__/ClineProvider.lockApiConfig.spec.ts @@ -331,7 +331,7 @@ describe("ClineProvider - Lock API Config Across Modes", () => { new ContextProxy(mockContext), new WebviewFocusTracker(), ) - // Tests provide explicit opening snapshots when they need saved mode profiles. + // These tests stub providerSettingsManager and expect it to be consulted for mode profiles. provider["initialModeConfigIds"] = Promise.resolve({}) // Mock getMcpHub method @@ -392,15 +392,10 @@ describe("ClineProvider - Lock API Config Across Modes", () => { apiProvider: providerIdentifiers.anthropic, }) - provider["initialModeConfigIds"] = Promise.resolve({ architect: "architect-profile-id" }) await provider.handleModeSwitch("architect") - expect(getModeConfigIdSpy).not.toHaveBeenCalled() - expect(activateProfileSpy).toHaveBeenCalledWith( - { name: "architect-profile" }, - expect.any(AbortSignal), - expect.any(Function), - ) + expect(getModeConfigIdSpy).toHaveBeenCalledWith("architect") + expect(activateProfileSpy).toHaveBeenCalledWith({ name: "architect-profile" }) }) }) }) diff --git a/src/core/webview/__tests__/ClineProvider.spec.ts b/src/core/webview/__tests__/ClineProvider.spec.ts index c3ef2c5f63..b529248867 100644 --- a/src/core/webview/__tests__/ClineProvider.spec.ts +++ b/src/core/webview/__tests__/ClineProvider.spec.ts @@ -15,7 +15,6 @@ import { type ClineMessage, type ExtensionMessage, type ExtensionState, - type HistoryItem, type RooCodeSettings, type WebviewMessage, ORGANIZATION_ALLOW_ALL, @@ -30,7 +29,6 @@ import { TelemetryService } from "@roo-code/telemetry" import { defaultModeSlug } from "../../../shared/modes" import { experimentDefault } from "../../../shared/experiments" import { setTtsEnabled } from "../../../utils/tts" -import { ProviderSettingsManager } from "../../config/ProviderSettingsManager" import { ContextProxy } from "../../config/ContextProxy" import { WorkspaceIndexingEnablementManager } from "../../../services/code-index/workspace-indexing-enablement-manager" import { Task, TaskOptions } from "../../task/Task" @@ -41,17 +39,11 @@ import { webviewMessageHandler } from "../webviewMessageHandler" import { Terminal } from "../../../integrations/terminal/Terminal" import { MessageManager } from "../../message-manager" import { forceFullModelDetailsLoad, hasLoadedFullDetails } from "../../../api/providers/fetchers/lmstudio" -import { - makeCompositeDisposable, - makeEventEmitter, - makeUri, - makeWorkspaceConfiguration, -} from "../../../test-utils/vscode" +import { makeCompositeDisposable, makeEventEmitter } from "../../../test-utils/vscode" import { WebviewFocusTracker } from "../WebviewFocusTracker" import { resolveChatProvider } from "../../../activate/resolveChatProvider" // Mock setup must come before imports. -vi.mock("@roo-code/ipc", () => ({ IpcServer: class {} })) vi.mock("../../prompts/sections/custom-instructions") vi.mock("p-wait-for", () => ({ @@ -567,7 +559,8 @@ describe("ClineProvider", () => { new ContextProxy(mockContext), new WebviewFocusTracker(), ) - // Tests provide explicit opening snapshots when they need saved mode profiles. + // Most tests stub providerSettingsManager and expect it to be consulted for mode profiles, + // so start without the snapshot the real manager would take of the seeded mode map. provider["initialModeConfigIds"] = Promise.resolve({}) defaultTaskOptions = { @@ -4621,7 +4614,6 @@ describe("ClineProvider", () => { apiProvider: providerIdentifiers.anthropic, } - provider["initialModeConfigIds"] = Promise.resolve({ architect: "test-id" }) ;(provider as any).providerSettingsManager = { getModeConfigId: vi.fn().mockResolvedValue("test-id"), listConfig: vi.fn().mockResolvedValue([profile]), @@ -4634,1075 +4626,38 @@ describe("ClineProvider", () => { await messageHandler({ type: "mode", text: "architect" }) // Should load the saved config for architect mode - expect(provider.providerSettingsManager.getModeConfigId).not.toHaveBeenCalled() - expect(provider.providerSettingsManager.activateProfile).toHaveBeenCalledWith( - { name: "test-config" }, - expect.any(AbortSignal), - expect.any(Function), - ) + expect(provider.providerSettingsManager.getModeConfigId).toHaveBeenCalledWith("architect") + expect(provider.providerSettingsManager.activateProfile).toHaveBeenCalledWith({ name: "test-config" }) expect(mockContext.globalState.update).toHaveBeenCalledWith("currentApiConfigName", "test-config") }) - describe("mode profile choices", () => { - const existingProfiles = (...ids: string[]) => - vi - .spyOn(provider.providerSettingsManager, "listConfig") - .mockResolvedValue(ids.map((id) => ({ name: `${id}-name`, id }))) - - it.each([false, true])("captures opening choices in the constructor (read failure: %s)", async (fails) => { - const snapshot = vi.spyOn(ProviderSettingsManager.prototype, "getModeConfigIds") - if (fails) snapshot.mockRejectedValueOnce(new Error("unreadable")) - else snapshot.mockResolvedValueOnce({ code: "opened-id" }) - const opened = new ClineProvider( - mockContext, - mockOutputChannel, - "sidebar", - new ContextProxy(mockContext), - new WebviewFocusTracker(), - ) - try { - expect(snapshot).toHaveBeenCalledOnce() - vi.spyOn(opened.providerSettingsManager, "listConfig").mockResolvedValue([ - { name: "opened", id: "opened-id" }, - ]) - const sharedLookup = vi - .spyOn(opened.providerSettingsManager, "getModeConfigId") - .mockResolvedValue("other-window-id") - snapshot.mockResolvedValue({ code: "other-window-id" }) - await expect(opened["getModeConfigId"]("code")).resolves.toBe(fails ? undefined : "opened-id") - expect(sharedLookup).not.toHaveBeenCalled() - } finally { - await opened.dispose() - snapshot.mockRestore() - } - }) - - it.each([false, true])( - "keeps the current profile without seeding a shared default (read failure: %s)", - async (fails) => { - const manager = provider.providerSettingsManager - await manager.import({ - currentApiConfigName: "current", - apiConfigs: { current: { id: "current-id" }, saved: { id: "saved-id" } }, - modeApiConfigs: fails ? { code: "saved-id" } : {}, - }) - await provider.contextProxy.setValue("currentApiConfigName", "current") - const snapshot = vi.spyOn(manager, "getModeConfigIds") - if (fails) snapshot.mockRejectedValueOnce(new Error("temporarily unreadable")) - provider["captureInitialModeConfigIds"]() - await provider["initialModeConfigIds"] - - // Storage has recovered by the time the mode switch reads profiles and could write a default. - const write = vi.spyOn(manager, "setModeConfig") - await provider["handleModeSwitchUnlocked"]("code", null) - - expect(write).not.toHaveBeenCalled() - await expect(manager.getModeConfigId("code")).resolves.toBe(fails ? "saved-id" : undefined) - expect(provider["getGlobalState"]("currentApiConfigName")).toBe("current") - }, - ) - - it.each([false, true])( - "preserves shared defaults written after this window opened (shared mapping exists: %s)", - async (hasSharedMapping) => { - const manager = provider.providerSettingsManager - provider["initialModeConfigIds"] = Promise.resolve({}) - await manager.import({ - currentApiConfigName: "current", - apiConfigs: { current: { id: "current-id" }, other: { id: "other-id" } }, - modeApiConfigs: hasSharedMapping ? { code: "other-id" } : {}, - }) - await provider.contextProxy.setValue("currentApiConfigName", "current") - const write = vi.spyOn(manager, "setModeConfig") - const activate = vi.spyOn(manager, "activateProfile") - - await provider["handleModeSwitchUnlocked"]("code", null) - - expect(write).not.toHaveBeenCalled() - expect(activate).not.toHaveBeenCalled() - await expect(manager.getModeConfigId("code")).resolves.toBe(hasSharedMapping ? "other-id" : undefined) - expect(provider["getGlobalState"]("currentApiConfigName")).toBe("current") - }, - ) - - it.each(["snapshot", "local"])("shares the window's %s choice with late-opening tabs", async (source) => { - provider["initialModeConfigIds"] = Promise.resolve({ code: "opened-id" }) - if (source === "local") provider.adoptModeConfigIds({ code: "local-id" }) - const snapshot = vi - .spyOn(ProviderSettingsManager.prototype, "getModeConfigIds") - .mockResolvedValue({ code: "other-window-id" }) - const tab = new ClineProvider( - mockContext, - mockOutputChannel, - "editor", - provider.contextProxy, - provider.webviewFocusTracker, - ) - try { - expect(snapshot).not.toHaveBeenCalled() - vi.spyOn(tab.providerSettingsManager, "listConfig").mockResolvedValue([ - { name: "opened", id: "opened-id" }, - { name: "local", id: "local-id" }, - ]) - const expectedName = source === "local" ? "local" : "opened" - vi.spyOn(tab.providerSettingsManager, "getProfile").mockResolvedValue({ - name: expectedName, - id: `${expectedName}-id`, - apiProvider: providerIdentifiers.anthropic, - }) - const activate = vi.fn() - tab["activateProviderProfileUnlocked"] = activate - - await tab["handleModeSwitchUnlocked"]("code", null) - - expect(activate).toHaveBeenCalledWith( - { name: expectedName }, - { persistModeConfig: false, persistTaskHistory: false, skipCurrentTaskRebuild: true }, - undefined, - ) - await expect(tab["getModeConfigId"]("code")).resolves.toBe(`${expectedName}-id`) - - // The parent double supplies only the execution context and flush methods read during delegation. - const parent = { - taskId: "tab-parent", - apiConfiguration: { apiProvider: providerIdentifiers.anthropic }, - getTaskMode: vi.fn().mockResolvedValue("architect"), - getTaskApiConfigName: vi.fn().mockResolvedValue("parent-profile"), - flushPendingToolResultsToHistory: vi.fn().mockResolvedValue(true), - } as unknown as Task - // The child double supplies the identity and run method consumed by the scheduler. - const child = { taskId: "tab-child", run: vi.fn().mockResolvedValue(undefined) } as unknown as Task - vi.spyOn(tab, "getCurrentTask").mockReturnValue(parent) - vi.spyOn(tab, "removeClineFromStack").mockResolvedValue(undefined) - const create = vi.spyOn(tab, "createTask").mockResolvedValue(child) - vi.spyOn(tab["taskHistoryStore"], "invalidate").mockResolvedValue(undefined) - vi.spyOn(tab["taskHistoryStore"], "get").mockReturnValue(undefined) - vi.spyOn(tab["taskHistoryStore"], "atomicReadAndUpdate").mockResolvedValue([]) - await tab.delegateParentAndOpenChild({ - parentTaskId: "tab-parent", - message: "Child", - initialTodos: [], - mode: "code", - }) - expect(create).toHaveBeenCalledWith( - "Child", - undefined, - parent, - expect.objectContaining({ - handoffExecutionContext: expect.objectContaining({ mode: "code", apiConfigName: expectedName }), - }), - ) - - // Later explicit choices and imports also belong to the window, in either direction. - vi.spyOn(tab.providerSettingsManager, "setModeConfig").mockResolvedValue(undefined) - await tab.setModeConfig("code", "local-id") - existingProfiles("local-id", "opened-id") - await expect(provider["getModeConfigId"]("code")).resolves.toBe("local-id") - provider.adoptModeConfigIds({ code: "opened-id" }) - await expect(tab["getModeConfigId"]("code")).resolves.toBe("opened-id") - } finally { - await tab.dispose() - snapshot.mockRestore() - } - }) - - it("restores a cached mode profile without overwriting another window's shared choice", async () => { - const manager = provider.providerSettingsManager - await manager.import({ - currentApiConfigName: "other", - apiConfigs: { - local: { id: "local-id", apiProvider: providerIdentifiers.anthropic }, - other: { id: "other-id", apiProvider: providerIdentifiers.openai }, - }, - modeApiConfigs: { code: "other-id" }, - }) - provider.adoptModeConfigIds({ code: "local-id" }) - const write = vi.spyOn(manager, "setModeConfig") - const activate = vi.spyOn(manager, "activateProfile") - - await provider["handleModeSwitchUnlocked"]("code", null) - - expect(activate).toHaveBeenCalledWith({ name: "local" }, expect.any(AbortSignal), expect.any(Function)) - expect(write).not.toHaveBeenCalled() - await expect(manager.getModeConfigId("code")).resolves.toBe("other-id") - await expect(provider["getModeConfigId"]("code")).resolves.toBe("local-id") - }) - - it.each([false, true])( - "does not seed an unmapped mode across a delayed read (cancelled: %s)", - async (cancel) => { - const manager = provider.providerSettingsManager - provider["initialModeConfigIds"] = Promise.resolve({}) - let release = () => {} - const pending = new Promise((resolve) => { - release = resolve - }) - const list = vi.spyOn(manager, "listConfig").mockImplementationOnce(async () => { - await pending - return [{ name: "current-config", id: "current-id" }] - }) - // Seeding no longer reads shared mappings, so there is no check/write gap to race. - const lookup = vi.spyOn(manager, "getModeConfigId") - const write = vi.spyOn(manager, "setModeConfig") - const controller = new AbortController() - const switched = provider["handleModeSwitchUnlocked"]("code", null, controller.signal) - await vi.waitFor(() => expect(list).toHaveBeenCalledOnce()) - if (cancel) controller.abort() - await manager.import({ - currentApiConfigName: "other", - apiConfigs: { other: { id: "other-id" } }, - modeApiConfigs: { code: "other-id" }, - }) - release() - await switched - - expect(lookup).not.toHaveBeenCalled() - expect(write).not.toHaveBeenCalled() - expect(provider["localModeConfigIds"].has("code")).toBe(false) - await expect(manager.getModeConfigId("code")).resolves.toBe("other-id") - }, - ) - - it.each([false, true])("handles a mode write waiting for the storage lock (cancelled: %s)", async (cancel) => { - const manager = provider.providerSettingsManager - let release = () => {} - const pending = new Promise((resolve) => { - release = resolve - }) - const originalStore = vi.mocked(mockContext.secrets.store).getMockImplementation()! - const store = vi.spyOn(mockContext.secrets, "store").mockImplementationOnce(async (key, value) => { - await pending - await originalStore(key, value) - }) - const imported = manager.import({ - currentApiConfigName: "imported", - apiConfigs: { imported: { id: "imported-id" }, selected: { id: "selected-id" } }, - modeApiConfigs: { code: "imported-id" }, - }) - await vi.waitFor(() => expect(store).toHaveBeenCalledOnce()) - const controller = new AbortController() - const write = provider.setModeConfig("code", "selected-id", controller.signal) - expect(provider["localModeConfigIds"].get("code")).toBe("selected-id") - if (cancel) controller.abort() - release() - const result = cancel - ? expect(write).rejects.toMatchObject({ - name: "Error", - message: "Failed to set mode config: AbortError: This operation was aborted", - }) - : expect(write).resolves.toBeUndefined() - await Promise.all([imported, result]) - - await expect(manager.getModeConfigId("code")).resolves.toBe(cancel ? "imported-id" : "selected-id") - expect(provider["localModeConfigIds"].get("code")).toBe(cancel ? undefined : "selected-id") - }) - - it.each(["queued", "persisting"])( - "finishes committed persistence but skips cancelled activation work when its mode write is %s", - async (stage) => { - await provider.setValue("mode", "code") - const manager = provider.providerSettingsManager - vi.spyOn(manager, "activateProfile").mockResolvedValue({ - name: "selected", - id: "selected-id", - apiProvider: providerIdentifiers.anthropic, - }) - let release = () => {} - const pending = new Promise((resolve) => { - release = resolve - }) - const write = vi - .spyOn(manager, "setModeConfig") - .mockImplementationOnce(async (_mode, _id, onPersisted) => { - await pending - onPersisted?.() - }) - const select = vi.spyOn(provider, "setModeConfig") - const preceding = stage === "queued" ? provider.setModeConfig("code", "previous-id") : Promise.resolve() - const rebuild = vi.fn(provider["updateTaskApiHandlerIfNeeded"].bind(provider)) - provider["updateTaskApiHandlerIfNeeded"] = rebuild - const sticky = vi.fn(provider["persistStickyProviderProfileToCurrentTask"].bind(provider)) - provider["persistStickyProviderProfileToCurrentTask"] = sticky - const controller = new AbortController() - const activation = provider["activateProviderProfileUnlocked"]( - { name: "selected" }, - { skipCurrentTaskRebuild: true }, - controller.signal, - ) - await vi.waitFor(() => expect(select).toHaveBeenCalledTimes(stage === "queued" ? 2 : 1)) - controller.abort() - release() - await Promise.all([preceding, activation]) - - expect(write).toHaveBeenCalledTimes(stage === "queued" ? 2 : 1) - expect(provider["localModeConfigIds"].get("code")).toBe("selected-id") - - expect(rebuild).not.toHaveBeenCalled() - expect(sticky).not.toHaveBeenCalled() - }, - ) - - it.each([false, true])( - "finishes committed activation persistence after disposal (context failure: %s)", - async (fails) => { - const manager = provider.providerSettingsManager - await provider.setValue("mode", "code") - await manager.import({ - currentApiConfigName: "opened", - apiConfigs: { - opened: { id: "opened-id", apiProvider: providerIdentifiers.anthropic }, - closed: { id: "closed-id", apiProvider: providerIdentifiers.anthropic }, - }, - modeApiConfigs: { code: "opened-id" }, - }) - let release = () => {} - const pending = new Promise((resolve) => { - release = resolve - }) - const originalList = manager.listConfig.bind(manager) - const list = vi.spyOn(manager, "listConfig").mockImplementationOnce(async () => { - await pending - return originalList() - }) - const rebuild = vi.fn(provider["updateTaskApiHandlerIfNeeded"].bind(provider)) - provider["updateTaskApiHandlerIfNeeded"] = rebuild - const sticky = vi.fn(provider["persistStickyProviderProfileToCurrentTask"].bind(provider)) - provider["persistStickyProviderProfileToCurrentTask"] = sticky - const activation = provider.activateProviderProfile({ name: "closed" }) - const result = fails - ? expect(activation).rejects.toThrow( - "Profile activation may be partially persisted: settings failure", - ) - : expect(activation).resolves.toBeUndefined() - await vi.waitFor(() => expect(list).toHaveBeenCalledOnce()) - await expect(manager["load"]()).resolves.toMatchObject({ currentApiConfigName: "closed" }) - if (fails) - vi.spyOn(provider.contextProxy, "setProviderSettings").mockRejectedValueOnce( - new Error("settings failure"), - ) - await provider.dispose() - release() - await result - - if (!fails) { - expect(provider.getValue("currentApiConfigName")).toBe("closed") - await expect(manager.getModeConfigId("code")).resolves.toBe("closed-id") - } - expect(rebuild).not.toHaveBeenCalled() - expect(sticky).not.toHaveBeenCalled() - }, - ) - - it("rejects a delegation profile lookup failure before changing the parent or creating a child", async () => { - const parent = new Task(defaultTaskOptions) - parent.getTaskMode = vi.fn().mockResolvedValue("code") - parent.getTaskApiConfigName = vi.fn().mockResolvedValue("parent-profile") - parent.apiConfiguration = { apiProvider: providerIdentifiers.anthropic } - vi.spyOn(provider, "getCurrentTask").mockReturnValue(parent) - vi.spyOn(provider.taskHistoryStore, "invalidate").mockResolvedValue(undefined) - vi.spyOn(provider.taskHistoryStore, "get").mockReturnValue(undefined) - const persist = vi.spyOn(provider.taskHistoryStore, "atomicReadAndUpdate") - const create = vi.spyOn(provider, "createTask") - const remove = vi.spyOn(provider, "removeClineFromStack") - provider["initialModeConfigIds"] = Promise.resolve({ architect: "selected-id" }) - vi.spyOn(provider.providerSettingsManager, "listConfig").mockRejectedValue( - new Error("profiles unavailable"), - ) - - await expect( - provider.delegateParentAndOpenChild({ - parentTaskId: parent.taskId, - message: "Child", - initialTodos: [], - mode: "architect", - }), - ).rejects.toThrow("profiles unavailable") - expect(provider.getCurrentTask()).toBe(parent) - expect(parent.apiConfiguration).toEqual({ apiProvider: providerIdentifiers.anthropic }) - expect(persist).not.toHaveBeenCalled() - expect(remove).not.toHaveBeenCalled() - expect(create).not.toHaveBeenCalled() - }) - - it.each(["mode switch", "profile activation"] as const)( - "restores matching mode and profile after disposal during a committed %s", - async (operation) => { - const manager = provider.providerSettingsManager - await manager.import({ - currentApiConfigName: "old", - apiConfigs: { - old: { id: "old-id", apiProvider: providerIdentifiers.anthropic }, - selected: { id: "selected-id", apiProvider: providerIdentifiers.openai }, - }, - modeApiConfigs: {}, - }) - await provider.setValue("mode", "code") - await provider.setValue("currentApiConfigName", "old") - provider.adoptModeConfigIds({ architect: "selected-id" }) - const tab = new ClineProvider( - mockContext, - mockOutputChannel, - "editor", - provider.contextProxy, - provider.webviewFocusTracker, - ) - const task = new Task(defaultTaskOptions) - task.setTaskApiConfigName = vi.fn() - let history: HistoryItem = { - id: task.taskId, - number: 1, - ts: 1, - task: "Restore", - mode: "code", - apiConfigName: "old", - tokensIn: 0, - tokensOut: 0, - totalCost: 0, - } - const current = vi.spyOn(tab, "getCurrentTask").mockReturnValue(task) - tab["getTaskHistoryItem"] = vi.fn(() => history) - let release = () => {} - const pending = new Promise((resolve) => { - release = resolve - }) - const entered = vi.fn() - vi.spyOn(tab, "updateTaskHistory").mockImplementation(async (item) => { - if (operation === "mode switch") { - entered() - await pending - } - history = item - return [history] - }) - if (operation === "profile activation") { - const originalStore = vi.mocked(mockContext.secrets.store).getMockImplementation()! - vi.spyOn(mockContext.secrets, "store").mockImplementationOnce(async (key, value) => { - entered() - await pending - await originalStore(key, value) - }) - } - try { - const changing = - operation === "mode switch" - ? tab.handleModeSwitch("architect", task) - : tab.activateProviderProfile({ name: "selected" }) - await vi.waitFor(() => expect(entered).toHaveBeenCalledOnce()) - await tab.dispose() - current.mockReturnValue(undefined) - release() - await changing - const expectedMode = operation === "mode switch" ? "architect" : "code" - expect(history).toMatchObject({ mode: expectedMode, apiConfigName: "selected" }) - vi.spyOn(provider, "postStateToWebview").mockResolvedValue(undefined) - await provider.createTaskWithHistoryItem(history) - expect(provider.getValue("mode")).toBe(expectedMode) - expect(provider.getValue("currentApiConfigName")).toBe("selected") - expect(Task).toHaveBeenLastCalledWith( - expect.objectContaining({ - historyItem: expect.objectContaining({ mode: expectedMode, apiConfigName: "selected" }), - apiConfiguration: expect.objectContaining({ apiProvider: providerIdentifiers.openai }), - }), - ) - } finally { - release() - await tab.dispose() - } - }, - ) - - it.each(["lock", "load"] as const)( - "settles a disposed tab's save before a pending %s finishes", - async (stage) => { - await provider["initialModeConfigIds"] - const tab = new ClineProvider( - mockContext, - mockOutputChannel, - "editor", - provider.contextProxy, - provider.webviewFocusTracker, - ) - const manager = tab.providerSettingsManager - let release = () => {} - const pending = new Promise((resolve) => { - release = resolve - }) - const entered = vi.fn() - let locked = Promise.resolve() - if (stage === "lock") { - locked = manager["lock"](async () => { - entered() - await pending - }) - } else { - vi.spyOn(mockContext.secrets, "get").mockImplementationOnce(async () => { - entered() - await pending - return undefined - }) - } - const store = vi.spyOn(mockContext.secrets, "store") - const save = vi.spyOn(manager, "saveConfig") - try { - const saving = tab.upsertProviderProfile("cancelled", {}, false) - await vi.waitFor(() => { - expect(entered).toHaveBeenCalledOnce() - expect(save).toHaveBeenCalledOnce() - }) - await tab.dispose() - await expect(saving).resolves.toBeUndefined() - expect(store).not.toHaveBeenCalled() - release() - await locked - await vi.waitFor(() => expect(tab["modeProfileState"].mutations.size).toBe(0)) - expect(store).not.toHaveBeenCalled() - } finally { - release() - await tab.dispose() - } - }, - ) - - it("finishes an inactive profile save after tab disposal and prevents a duplicate API retry", async () => { - const { API } = await import("../../../extension/api") - const { makeClineProviderFactory } = await import("../../../test-utils/provider") - const tab = new ClineProvider( - mockContext, - mockOutputChannel, - "editor", - provider.contextProxy, - provider.webviewFocusTracker, - ) - const manager = provider.providerSettingsManager - await provider["initialModeConfigIds"] - const originalStore = vi.mocked(mockContext.secrets.store).getMockImplementation()! - let release = () => {} - const pending = new Promise((resolve) => { - release = resolve - }) - const save = vi.spyOn(manager, "saveConfig") - const store = vi.spyOn(mockContext.secrets, "store").mockImplementationOnce(async (key, value) => { - await pending - await originalStore(key, value) - }) - const post = vi.spyOn(tab, "postStateToWebview").mockResolvedValue(undefined) - try { - let settled = false - const saving = tab - .upsertProviderProfile("inactive", { apiProvider: providerIdentifiers.anthropic }, false) - .finally(() => { - settled = true - }) - await vi.waitFor(() => expect(store).toHaveBeenCalledOnce()) - await tab.dispose() - await new Promise((resolve) => setImmediate(resolve)) - expect(settled).toBe(false) - release() - const id = await saving - expect(id).toEqual(expect.any(String)) - expect(provider.getProviderProfileEntry("inactive")).toMatchObject({ id, name: "inactive" }) - expect(post).not.toHaveBeenCalled() - const api = new API(mockOutputChannel, provider, makeClineProviderFactory()) - await expect( - api.createProfile("inactive", { apiProvider: providerIdentifiers.openai }, false), - ).rejects.toThrow('Profile with name "inactive" already exists') - expect(save).toHaveBeenCalledOnce() - await expect(manager.getProfile({ name: "inactive" })).resolves.toMatchObject({ - apiProvider: providerIdentifiers.anthropic, - }) - } finally { - release() - await tab.dispose() - } - }) - - it("invalidates a closed tab's queued activations while a reopened tab can finish its choice", async () => { - await provider.setValue("mode", "code") - const manager = provider.providerSettingsManager - await manager.import({ - currentApiConfigName: "opened", - apiConfigs: { - opened: { id: "opened-id" }, - closed: { id: "closed-id" }, - reopened: { id: "reopened-id" }, - }, - modeApiConfigs: {}, - }) - const makeTab = () => - new ClineProvider( - mockContext, - mockOutputChannel, - "editor", - provider.contextProxy, - provider.webviewFocusTracker, - ) - const tab = makeTab() - let reopened: ClineProvider | undefined - let release = () => {} - const pending = new Promise((resolve) => { - release = resolve - }) - try { - const originalStore = vi.mocked(mockContext.secrets.store).getMockImplementation()! - const store = vi.spyOn(mockContext.secrets, "store").mockImplementationOnce(async (key, value) => { - await pending - await originalStore(key, value) - }) - const first = provider.setModeConfig("code", "opened-id") - await vi.waitFor(() => expect(store).toHaveBeenCalledOnce()) - const activate = vi.spyOn(tab.providerSettingsManager, "activateProfile").mockResolvedValue({ - name: "closed", - id: "closed-id", - apiProvider: providerIdentifiers.anthropic, - }) - const write = vi.spyOn(tab.providerSettingsManager, "setModeConfig") - const select = vi.spyOn(tab, "setModeConfig") - const rebuild = vi.fn(tab["updateTaskApiHandlerIfNeeded"].bind(tab)) - tab["updateTaskApiHandlerIfNeeded"] = rebuild - const sticky = vi.fn(tab["persistStickyProviderProfileToCurrentTask"].bind(tab)) - tab["persistStickyProviderProfileToCurrentTask"] = sticky - const active = tab.activateProviderProfile({ name: "closed" }, { skipCurrentTaskRebuild: true }) - await vi.waitFor(() => expect(select).toHaveBeenCalledOnce()) - const queued = expect( - tab.activateProviderProfile({ name: "closed" }, { skipCurrentTaskRebuild: true }), - ).rejects.toThrow("Provider disposed") - await tab.dispose() - await queued - reopened = makeTab() - const freshActivate = vi.spyOn(reopened.providerSettingsManager, "activateProfile").mockResolvedValue({ - name: "reopened", - id: "reopened-id", - apiProvider: providerIdentifiers.anthropic, - }) - const fresh = reopened.activateProviderProfile({ name: "reopened" }, { skipCurrentTaskRebuild: true }) - await new Promise((resolve) => setImmediate(resolve)) - expect(freshActivate).toHaveBeenCalledOnce() - release() - await Promise.all([first, active, fresh]) - - expect(activate).toHaveBeenCalledTimes(2) - expect(write).toHaveBeenCalledTimes(2) - expect(rebuild).not.toHaveBeenCalled() - expect(sticky).not.toHaveBeenCalled() - await expect(manager.getModeConfigId("code")).resolves.toBe("reopened-id") - await expect(reopened["getModeConfigId"]("code")).resolves.toBe("reopened-id") - } finally { - release() - await tab.dispose() - await reopened?.dispose() - } - }) - - it("serializes a tab import with a sidebar mode write and publishes in persisted order", async () => { - const manager = provider.providerSettingsManager - await manager.import({ - currentApiConfigName: "chosen", - apiConfigs: { chosen: { id: "chosen-id" }, imported: { id: "imported-id" } }, - modeApiConfigs: {}, - }) - const tab = new ClineProvider( - mockContext, - mockOutputChannel, - "editor", - provider.contextProxy, - provider.webviewFocusTracker, - ) - let release = () => {} - const pending = new Promise((resolve) => { - release = resolve - }) - try { - const originalStore = vi.mocked(mockContext.secrets.store).getMockImplementation()! - const store = vi.spyOn(mockContext.secrets, "store").mockImplementationOnce(async (key, value) => { - await pending - await originalStore(key, value) - }) - const chosen = provider.setModeConfig("code", "chosen-id") - await vi.waitFor(() => expect(store).toHaveBeenCalledOnce()) - const publish = vi.fn(() => tab.adoptModeConfigIds({ code: "imported-id" })) - const imported = tab.providerSettingsManager.import( - { - currentApiConfigName: "imported", - apiConfigs: { - chosen: { id: "chosen-id" }, - imported: { id: "imported-id" }, - added: { id: "added-id" }, - }, - modeApiConfigs: { code: "imported-id" }, - }, - publish, - ) - await new Promise((resolve) => setImmediate(resolve)) - expect(publish).not.toHaveBeenCalled() - release() - await Promise.all([chosen, imported]) - - expect(publish).toHaveBeenCalledOnce() - await expect(manager.getModeConfigId("code")).resolves.toBe("imported-id") - await expect(provider["getModeConfigId"]("code")).resolves.toBe("imported-id") - await expect(tab["getModeConfigId"]("code")).resolves.toBe("imported-id") - expect(await manager.listConfig()).toEqual( - expect.arrayContaining([expect.objectContaining({ id: "added-id" })]), - ) - } finally { - release() - await tab.dispose() - } - }) - - it("does not adopt shared mappings when an import omits modeApiConfigs", async () => { - const manager = provider.providerSettingsManager - await manager.import({ - currentApiConfigName: "local", - apiConfigs: { local: { id: "local-id" }, shared: { id: "shared-id" } }, - modeApiConfigs: { code: "shared-id" }, - }) - provider.adoptModeConfigIds({ code: "local-id" }) - const fsPromises = (await import("fs/promises")).default - vi.mocked(fsPromises.readFile).mockResolvedValueOnce( - JSON.stringify({ - providerProfiles: { - currentApiConfigName: "imported", - apiConfigs: { imported: { id: "imported-id", apiProvider: providerIdentifiers.anthropic } }, - }, - globalSettings: {}, - }), - ) - const adopt = vi.spyOn(provider, "adoptModeConfigIds") - const { importSettingsFromPath } = await import("../../config/importExport") - const result = await importSettingsFromPath("/settings.json", { - providerSettingsManager: manager, - contextProxy: provider.contextProxy, - customModesManager: provider.customModesManager, - onModeConfigIdsImported: (ids) => provider.adoptModeConfigIds(ids), - }) - - expect(result.success).toBe(true) - expect(adopt).toHaveBeenCalledExactlyOnceWith({}) - await expect(manager.getModeConfigId("code")).resolves.toBe("shared-id") - await expect(provider["getModeConfigId"]("code")).resolves.toBe("local-id") - }) - - it("logs a fixed snapshot failure message without secret-storage error content", async () => { - vi.spyOn(provider.providerSettingsManager, "getModeConfigIds").mockRejectedValueOnce( - new Error("api-key-must-not-appear"), - ) - const log = vi.spyOn(provider, "log") - provider["captureInitialModeConfigIds"]() - await provider["initialModeConfigIds"] - - expect(log).toHaveBeenCalledWith("Failed to snapshot mode profile choices") - expect(log.mock.calls.flat().join("\n")).not.toContain("api-key-must-not-appear") - }) - - it.each([false, true])( - "awaits a committing activation beyond timeout and reports its outcome (context failure: %s)", - async (fails) => { - vi.useFakeTimers() - let release = () => {} - try { - const manager = provider.providerSettingsManager - await provider.setValue("mode", "code") - await manager.import({ - currentApiConfigName: "first", - apiConfigs: { - first: { id: "first-id", apiProvider: providerIdentifiers.anthropic }, - second: { id: "second-id", apiProvider: providerIdentifiers.anthropic }, - }, - modeApiConfigs: {}, - }) - const pending = new Promise((resolve) => { - release = resolve - }) - const originalList = manager.listConfig.bind(manager) - const list = vi.spyOn(manager, "listConfig").mockImplementationOnce(async () => { - await pending - return originalList() - }) - const activate = vi.spyOn(manager, "activateProfile") - let finished = false - const first = provider.activateProviderProfile({ name: "first" }) - const outcome = first.then( - () => { - finished = true - return undefined - }, - (error: unknown) => { - finished = true - return error - }, - ) - await vi.advanceTimersByTimeAsync(0) - expect(list).toHaveBeenCalledOnce() - const firstSignal = activate.mock.calls[0][1] - if (!firstSignal) throw new Error("Missing activation signal") - await vi.advanceTimersByTimeAsync(ClineProvider.PENDING_OPERATION_TIMEOUT_MS + 1) - expect(finished).toBe(false) - expect(firstSignal.aborted).toBe(false) - const second = provider.activateProviderProfile({ name: "second" }) - await vi.advanceTimersByTimeAsync(0) - expect(activate).toHaveBeenCalledOnce() - if (fails) - vi.spyOn(provider.contextProxy, "setProviderSettings").mockRejectedValueOnce( - new Error("settings failed after timeout"), - ) - release() - await vi.advanceTimersByTimeAsync(0) - const error = await outcome - if (fails) - expect(error).toMatchObject({ - name: "Error", - message: "Profile activation may be partially persisted: settings failed after timeout", - }) - else expect(error).toBeUndefined() - await second - - expect(activate).toHaveBeenCalledTimes(2) - expect(provider["modeProfileState"].committingMutationSignals.has(firstSignal)).toBe(false) - expect(provider["modeProfileState"].committingMutationSignals.size).toBe(0) - } finally { - release() - vi.useRealTimers() - } - }, - ) - - it.each([false, true])( - "drains a delayed mode-switch history write before another tab selects a mode (disposed: %s)", - async (dispose) => { - const task = new Task(defaultTaskOptions) - task["_taskMode"] = "code" - const history: HistoryItem = { - id: task.taskId, - number: 1, - ts: 1, - task: "Mode switch", - mode: "code", - tokensIn: 0, - tokensOut: 0, - totalCost: 0, - } - provider["getTaskHistoryItem"] = vi.fn().mockReturnValue(history) - let release = () => {} - const pending = new Promise((resolve) => { - release = resolve - }) - const write = vi.spyOn(provider, "updateTaskHistory").mockImplementationOnce(async () => { - await pending - return [history] - }) - const first = provider.handleModeSwitch("ask", task) - const outcome = first.then( - () => undefined, - (error: unknown) => error, - ) - await vi.waitFor(() => expect(write).toHaveBeenCalledOnce()) - if (dispose) await provider.dispose() - const tab = new ClineProvider( - mockContext, - mockOutputChannel, - "editor", - provider.contextProxy, - provider.webviewFocusTracker, - ) - try { - vi.spyOn(tab, "postStateToWebview").mockResolvedValue(undefined) - let finished = false - const second = tab.handleModeSwitch("architect", null).then(() => { - finished = true - }) - await new Promise((resolve) => setImmediate(resolve)) - expect(finished).toBe(false) - release() - await second - - expect(await outcome).toBeUndefined() - expect(tab.getValue("mode")).toBe("architect") - expect(task["_taskMode"]).toBe("ask") - } finally { - release() - await tab.dispose() - } - }, - ) - - it.each(["snapshot", "profiles"])("stops a cancelled mode switch during %s lookup", async (stage) => { - let release = () => {} - const pending = new Promise((resolve) => { - release = resolve - }) - provider["initialModeConfigIds"] = - stage === "snapshot" - ? pending.then(() => ({ code: "opened-id" })) - : Promise.resolve({ code: "opened-id" }) - const list = vi.spyOn(provider.providerSettingsManager, "listConfig").mockImplementation(async () => { - if (stage === "profiles") await pending - return [{ name: "opened", id: "opened-id" }] - }) - const lookup = vi.fn(provider["getModeConfigId"].bind(provider)) - provider["getModeConfigId"] = lookup - const controller = new AbortController() - const switched = provider["handleModeSwitchUnlocked"]("code", null, controller.signal) - await vi.waitFor(() => expect(lookup).toHaveBeenCalledOnce()) - if (stage === "profiles") await vi.waitFor(() => expect(list).toHaveBeenCalledOnce()) - controller.abort() - release() - await switched - expect(list).toHaveBeenCalledTimes(stage === "snapshot" ? 0 : 1) - expect(provider["localModeConfigIds"].has("code")).toBe(false) - }) - - it.each(["manual", "automatic", "explicit-path"])( - "adopts imported choices through the %s import entry point", - async (entry) => { - const filePath = "/settings.json" - const fsPromises = (await import("fs/promises")).default - const originalReadFile = vi.mocked(fsPromises.readFile).getMockImplementation()! - vi.mocked(fsPromises.readFile).mockResolvedValue( - JSON.stringify({ - providerProfiles: { - currentApiConfigName: "imported", - apiConfigs: { imported: { id: "imported-id", apiProvider: providerIdentifiers.anthropic } }, - modeApiConfigs: { code: "imported-id" }, - }, - globalSettings: {}, - }), - ) - vi.spyOn(provider, "postStateToWebview").mockResolvedValue(undefined) - const options = { - providerSettingsManager: provider.providerSettingsManager, - contextProxy: provider.contextProxy, - customModesManager: provider.customModesManager, - provider, - } - if (entry === "explicit-path") { - vi.spyOn(fsPromises, "access").mockResolvedValueOnce(undefined) - const { importSettingsWithFeedback } = await import("../../config/importExport") - await importSettingsWithFeedback(options, filePath) - } else if (entry === "manual") { - vi.mocked(vscode.window.showOpenDialog).mockResolvedValueOnce([makeUri(filePath)]) - const { importSettingsWithFeedback } = await import("../../config/importExport") - await importSettingsWithFeedback(options) - } else { - const fsUtils = await import("../../../utils/fs") - const exists = vi.spyOn(fsUtils, "fileExistsAtPath").mockResolvedValue(true) - const originalGetConfiguration = vi - .mocked(vscode.workspace.getConfiguration) - .getMockImplementation()! - vi.mocked(vscode.workspace.getConfiguration).mockReturnValue( - makeWorkspaceConfiguration({ autoImportSettingsPath: filePath }), - ) - const { autoImportSettings } = await import("../../../utils/autoImportSettings") - await autoImportSettings(mockOutputChannel, { - ...options, - onModeConfigIdsImported: (ids) => provider.adoptModeConfigIds(ids), - }) - expect(mockOutputChannel.appendLine).toHaveBeenCalledWith( - expect.stringContaining("Successfully imported settings"), - ) - exists.mockRestore() - vi.mocked(vscode.workspace.getConfiguration).mockImplementation(originalGetConfiguration) - } - await expect(provider["getModeConfigId"]("code")).resolves.toBe("imported-id") - await expect(provider.providerSettingsManager.getModeConfigId("code")).resolves.toBe("imported-id") - vi.mocked(fsPromises.readFile).mockImplementation(originalReadFile) - }, - ) - - it.each(["import-first", "choice-first"])("keeps local choices in persisted order (%s)", async (order) => { - const manager = provider.providerSettingsManager - const profiles = { - currentApiConfigName: "imported", - apiConfigs: { imported: { id: "imported-id" }, chosen: { id: "chosen-id" } }, - modeApiConfigs: { code: "imported-id" }, - } - let release = () => {} - const pending = new Promise((resolve) => { - release = resolve - }) - const originalStore = vi.mocked(mockContext.secrets.store).getMockImplementation()! - vi.spyOn(mockContext.secrets, "store").mockImplementationOnce(async (key, value) => { - await pending - await originalStore(key, value) - }) - const imported = () => manager.import(profiles, () => provider.adoptModeConfigIds(profiles.modeApiConfigs)) - const chosen = () => provider.setModeConfig("code", "chosen-id") - const first = order === "import-first" ? imported() : chosen() - const second = order === "import-first" ? chosen() : imported() - release() - await Promise.all([first, second]) - const expected = order === "import-first" ? "chosen-id" : "imported-id" - await expect(manager.getModeConfigId("code")).resolves.toBe(expected) - await expect(provider["getModeConfigId"]("code")).resolves.toBe(expected) - }) - - it.each(["imported-id", "other-id"])( - "preserves an imported choice when an overlapping write of %s fails", - async (chosenId) => { - const manager = provider.providerSettingsManager - const profiles = { - currentApiConfigName: "imported", - apiConfigs: { imported: { id: "imported-id" }, previous: { id: "previous-id" } }, - modeApiConfigs: { code: "imported-id" }, - } - await provider.setModeConfig("code", "previous-id") - let release = () => {} - const pending = new Promise((resolve) => { - release = resolve - }) - const originalStore = vi.mocked(mockContext.secrets.store).getMockImplementation()! - const store = vi.spyOn(mockContext.secrets, "store") - store - .mockImplementationOnce(async (key, value) => { - await pending - await originalStore(key, value) - }) - .mockRejectedValueOnce(new Error("write failed")) - const imported = manager.import(profiles, () => provider.adoptModeConfigIds(profiles.modeApiConfigs)) - await vi.waitFor(() => expect(store).toHaveBeenCalledOnce()) - const failed = expect(provider.setModeConfig("code", chosenId)).rejects.toThrow("write failed") - release() - await imported - await failed - await expect(manager.getModeConfigId("code")).resolves.toBe("imported-id") - await expect(provider["getModeConfigId"]("code")).resolves.toBe("imported-id") - }, - ) + it("prefers this window's mode profile over one another window saved in shared storage", async () => { + await provider.resolveWebviewView(mockWebviewView) - it("prefers this window's mode profile over one another window saved in shared storage", async () => { - const manager = provider.providerSettingsManager - existingProfiles("this-window-id", "other-window-id") - vi.spyOn(manager, "getModeConfigId").mockResolvedValue("other-window-id") - vi.spyOn(manager, "setModeConfig").mockResolvedValue(undefined) + const manager = provider.providerSettingsManager + vi.spyOn(manager, "getModeConfigId").mockResolvedValue("other-window-id") + vi.spyOn(manager, "setModeConfig").mockResolvedValue(undefined) - await provider["setModeConfig"]("code", "this-window-id") + await provider["setModeConfig"]("code", "this-window-id") - expect(manager.setModeConfig).toHaveBeenCalledWith( - "code", - "this-window-id", - expect.any(Function), - expect.any(AbortSignal), - ) - await expect(provider["getModeConfigId"]("code")).resolves.toBe("this-window-id") - }) + expect(manager.setModeConfig).toHaveBeenCalledWith("code", "this-window-id") + await expect(provider["getModeConfigId"]("code")).resolves.toBe("this-window-id") + // A mode this window never chose still falls back to the shared value. + await expect(provider["getModeConfigId"]("architect")).resolves.toBe("other-window-id") + }) + describe("mode profile snapshot", () => { it("keeps the choice this window opened with when another window changes the shared value", async () => { provider["initialModeConfigIds"] = Promise.resolve({ architect: "opened-with-id" }) - existingProfiles("opened-with-id", "other-window-id") - const sharedLookup = vi - .spyOn(provider.providerSettingsManager, "getModeConfigId") - .mockResolvedValue("other-window-id") + vi.spyOn(provider.providerSettingsManager, "getModeConfigId").mockResolvedValue("other-window-id") await expect(provider["getModeConfigId"]("architect")).resolves.toBe("opened-with-id") - // A mode absent when this window opened keeps this window's current profile instead of - // one another window saved for it later. - await expect(provider["getModeConfigId"]("new-custom-mode")).resolves.toBeUndefined() - expect(sharedLookup).not.toHaveBeenCalled() + // A mode created after this window opened has no snapshot entry, so the shared value applies. + await expect(provider["getModeConfigId"]("new-custom-mode")).resolves.toBe("other-window-id") }) it("prefers an explicit local choice over the snapshot", async () => { provider["initialModeConfigIds"] = Promise.resolve({ architect: "opened-with-id" }) - existingProfiles("opened-with-id", "chosen-id") vi.spyOn(provider.providerSettingsManager, "setModeConfig").mockResolvedValue(undefined) await provider["setModeConfig"]("architect", "chosen-id") @@ -5710,270 +4665,13 @@ describe("ClineProvider", () => { await expect(provider["getModeConfigId"]("architect")).resolves.toBe("chosen-id") }) - it.each(["architect", "new-custom-mode"])( - "adopts imported defaults for %s without adopting other windows' writes", - async (mode) => { - provider["initialModeConfigIds"] = Promise.resolve({ architect: "opened-with-id" }) - existingProfiles("opened-with-id", "imported-id", "other-window-id") - vi.spyOn(provider.providerSettingsManager, "getModeConfigId").mockResolvedValue("other-window-id") - provider.adoptModeConfigIds({ [mode]: "imported-id" }) - - await expect(provider["getModeConfigId"](mode)).resolves.toBe("imported-id") - await expect(provider["getModeConfigId"]("unrelated-mode")).resolves.toBeUndefined() - }, - ) - - it("keeps the current profile when the snapshot cannot be read", async () => { + it("falls back to the shared value when the snapshot cannot be read", async () => { vi.spyOn(provider.providerSettingsManager, "getModeConfigIds").mockRejectedValue(new Error("unreadable")) vi.spyOn(provider.providerSettingsManager, "getModeConfigId").mockResolvedValue("shared-id") provider["captureInitialModeConfigIds"]() - await expect(provider["getModeConfigId"]("architect")).resolves.toBeUndefined() - expect(provider.providerSettingsManager.getModeConfigId).not.toHaveBeenCalled() - existingProfiles("chosen-id") - vi.spyOn(provider.providerSettingsManager, "setModeConfig").mockResolvedValue(undefined) - await provider.setModeConfig("architect", "chosen-id") - await expect(provider["getModeConfigId"]("architect")).resolves.toBe("chosen-id") - }) - - it("falls back to the shared mapping when the opening snapshot profile was removed", async () => { - provider["initialModeConfigIds"] = Promise.resolve({ code: "removed-id" }) - existingProfiles("shared-id") - vi.spyOn(provider.providerSettingsManager, "getModeConfigId").mockResolvedValue("shared-id") - - expect(provider["localModeConfigIds"].has("code")).toBe(false) - await expect(provider["getModeConfigId"]("code")).resolves.toBe("shared-id") - expect(provider.providerSettingsManager.getModeConfigId).toHaveBeenCalledExactlyOnceWith("code") - }) - - it("drops a local choice whose profile was removed and falls back to the shared mapping", async () => { - provider["initialModeConfigIds"] = Promise.resolve({}) - vi.spyOn(provider.providerSettingsManager, "setModeConfig").mockResolvedValue(undefined) - vi.spyOn(provider.providerSettingsManager, "getModeConfigId").mockResolvedValue("shared-id") - await provider["setModeConfig"]("code", "removed-id") - // Another window reset or deleted the profile this window chose. - existingProfiles("shared-id") - - await expect(provider["getModeConfigId"]("code")).resolves.toBe("shared-id") - expect(provider["localModeConfigIds"].has("code")).toBe(false) - }) - - it("preserves a local choice made while the initial snapshot is pending", async () => { - let resolveSnapshot = (_ids: Record) => {} - provider["initialModeConfigIds"] = new Promise>((resolve) => { - resolveSnapshot = resolve - }) - existingProfiles("new-id") - vi.spyOn(provider.providerSettingsManager, "setModeConfig").mockResolvedValue(undefined) - const sharedLookup = vi - .spyOn(provider.providerSettingsManager, "getModeConfigId") - .mockResolvedValue("other-window-id") - - const lookup = provider["getModeConfigId"]("code") - await provider.setModeConfig("code", "new-id") - resolveSnapshot({}) - - await expect(lookup).resolves.toBe("new-id") - expect(sharedLookup).not.toHaveBeenCalled() - }) - - it.each(["removed-id", "existing-id"])( - "preserves a newer local choice while validating %s", - async (previousId) => { - provider["initialModeConfigIds"] = Promise.resolve({ code: "opened-with-id" }) - vi.spyOn(provider.providerSettingsManager, "setModeConfig").mockResolvedValue(undefined) - const sharedLookup = vi - .spyOn(provider.providerSettingsManager, "getModeConfigId") - .mockResolvedValue("other-window-id") - await provider.setModeConfig("code", previousId) - let releaseLookup = () => {} - const pendingLookup = new Promise((resolve) => { - releaseLookup = resolve - }) - const profiles = [ - { name: "existing", id: "existing-id" }, - { name: "new", id: "new-id" }, - ] - const listConfig = vi.spyOn(provider.providerSettingsManager, "listConfig") - listConfig - .mockImplementationOnce(async () => { - await pendingLookup - return profiles - }) - .mockResolvedValue(profiles) - - const lookup = provider["getModeConfigId"]("code") - expect(listConfig).toHaveBeenCalledOnce() - await provider.setModeConfig("code", "new-id") - releaseLookup() - - await expect(lookup).resolves.toBe("new-id") - await expect(provider["getModeConfigId"]("code")).resolves.toBe("new-id") - expect(sharedLookup).not.toHaveBeenCalled() - }, - ) - - it("restores the previous local choice when the shared write fails", async () => { - provider["initialModeConfigIds"] = Promise.resolve({}) - existingProfiles("first-id", "second-id") - const sharedWrite = vi.spyOn(provider.providerSettingsManager, "setModeConfig") - sharedWrite.mockResolvedValueOnce(undefined) - await provider["setModeConfig"]("code", "first-id") - - sharedWrite.mockRejectedValueOnce(new Error("write failed")) - await expect(provider["setModeConfig"]("code", "second-id")).rejects.toThrow("write failed") - await expect(provider["getModeConfigId"]("code")).resolves.toBe("first-id") - - sharedWrite.mockRejectedValueOnce(new Error("write failed")) - await expect(provider["setModeConfig"]("architect", "second-id")).rejects.toThrow("write failed") - await expect(provider["getModeConfigId"]("architect")).resolves.toBeUndefined() - }) - - it.each(["first-id", "second-id"])( - "preserves a successful overlapping write of %s after the preceding write fails", - async (nextId) => { - existingProfiles("first-id", "second-id") - const sharedWrite = vi.spyOn(provider.providerSettingsManager, "setModeConfig").mockResolvedValue() - await provider.setModeConfig("code", "first-id") - let rejectWrite = (_error: Error) => {} - sharedWrite.mockImplementationOnce( - () => - new Promise((_resolve, reject) => { - rejectWrite = reject - }), - ) - const failed = provider.setModeConfig("code", "second-id") - const failure = expect(failed).rejects.toThrow("write failed") - const succeeded = provider.setModeConfig("code", nextId) - expect(sharedWrite).toHaveBeenCalledTimes(2) - rejectWrite(new Error("write failed")) - await failure - await succeeded - expect(sharedWrite).toHaveBeenLastCalledWith( - "code", - nextId, - expect.any(Function), - expect.any(AbortSignal), - ) - await expect(provider["getModeConfigId"]("code")).resolves.toBe(nextId) - }, - ) - - it.each(["activation", "profile save"])( - "drains an active %s before resetting and rejects later mutations", - async (operation) => { - const { t } = await import("../../../i18n") - await provider.setValue("mode", "code") - vi.mocked(vscode.window.showInformationMessage).mockResolvedValueOnce(t("common:answers.yes") as never) - vi.spyOn(provider, "postStateToWebview").mockResolvedValue(undefined) - vi.spyOn(provider, "postMessageToWebview").mockResolvedValue(undefined) - provider.customModesManager.resetCustomModes = vi.fn().mockResolvedValue(undefined) - const manager = provider.providerSettingsManager - await manager.import({ - currentApiConfigName: "opened", - apiConfigs: { - opened: { id: "opened-id", apiProvider: providerIdentifiers.anthropic }, - selected: { id: "selected-id", apiProvider: providerIdentifiers.anthropic }, - }, - modeApiConfigs: {}, - }) - let release = () => {} - const pending = new Promise((resolve) => { - release = resolve - }) - const originalActivate = manager.activateProfile.bind(manager) - const originalSave = manager.saveConfig.bind(manager) - const activate = vi.spyOn(manager, "activateProfile") - const save = vi.spyOn(manager, "saveConfig") - if (operation === "activation") { - activate.mockImplementationOnce(async (...args) => { - await pending - return originalActivate(...args) - }) - } else { - save.mockImplementationOnce(async (...args) => { - await pending - return originalSave(...args) - }) - } - const active = - operation === "activation" - ? provider.activateProviderProfile({ name: "selected" }) - : provider.upsertProviderProfile("selected", { apiProvider: providerIdentifiers.anthropic }) - await vi.waitFor(() => expect(operation === "activation" ? activate : save).toHaveBeenCalledOnce()) - const queued = expect(provider.activateProviderProfile({ name: "opened" })).rejects.toThrow( - "settings reset", - ) - const resetConfigs = vi.spyOn(manager, "resetAllConfigs") - const resetContext = vi.spyOn(provider.contextProxy, "resetAllState") - const resetting = provider.resetState() - await vi.waitFor(() => expect(provider["modeProfileState"].reset).toBeDefined()) - expect(resetConfigs).not.toHaveBeenCalled() - expect(resetContext).not.toHaveBeenCalled() - await expect(provider.activateProviderProfile({ name: "opened" })).rejects.toThrow("settings reset") - release() - const result = await active - if (operation === "profile save") expect(result).toBe("selected-id") - await Promise.all([queued, resetting]) - - expect(resetConfigs).toHaveBeenCalledOnce() - expect(await mockContext.secrets.get(manager["secretsKey"])).toBeUndefined() - expect(provider["localModeConfigIds"].size).toBe(0) - expect(provider["modeProfileState"].mutations.size).toBe(0) - expect(activate).toHaveBeenCalledTimes(operation === "activation" ? 1 : 0) - expect(save).toHaveBeenCalledTimes(operation === "profile save" ? 1 : 0) - }, - ) - - it("does not restore stale mode mappings when reset overlaps two queued same-mode writes", async () => { - const { t } = await import("../../../i18n") - vi.mocked(vscode.window.showInformationMessage).mockResolvedValueOnce(t("common:answers.yes") as never) - vi.spyOn(provider, "postStateToWebview").mockResolvedValue(undefined) - vi.spyOn(provider, "postMessageToWebview").mockResolvedValue(undefined) - provider.customModesManager.resetCustomModes = vi.fn().mockResolvedValue(undefined) - const manager = provider.providerSettingsManager - await manager.import({ - currentApiConfigName: "first", - apiConfigs: { first: { id: "first-id" }, second: { id: "second-id" } }, - modeApiConfigs: {}, - }) - let release = () => {} - const pending = new Promise((resolve) => { - release = resolve - }) - const originalStore = vi.mocked(mockContext.secrets.store).getMockImplementation()! - const store = vi.spyOn(mockContext.secrets, "store").mockImplementationOnce(async (key, value) => { - await pending - await originalStore(key, value) - }) - const first = provider.setModeConfig("code", "first-id") - await vi.waitFor(() => expect(store).toHaveBeenCalledOnce()) - const second = expect(provider.setModeConfig("code", "second-id")).rejects.toThrow("settings reset") - const resetConfigs = vi.spyOn(manager, "resetAllConfigs") - const resetting = provider.resetState() - await vi.waitFor(() => expect(provider["modeProfileState"].reset).toBeDefined()) - // Deletion waits for the active write; another selection during reset must also be ignored. - expect(resetConfigs).not.toHaveBeenCalled() - await expect(provider.setModeConfig("code", "second-id")).rejects.toThrow("settings reset") - release() - await Promise.all([first, second, resetting]) - - expect(await mockContext.secrets.get(manager["secretsKey"])).toBeUndefined() - const resetId = await manager.getModeConfigId("code") - expect(["first-id", "second-id"]).not.toContain(resetId) - await expect(provider["getModeConfigId"]("code")).resolves.toBe(resetId) - expect(provider["localModeConfigIds"].has("code")).toBe(false) - - // A fresh choice after reset can still be persisted and resolved. - await manager.import({ - currentApiConfigName: "fresh", - apiConfigs: { fresh: { id: "fresh-id" } }, - modeApiConfigs: {}, - }) - await provider.setModeConfig("code", "fresh-id") - await expect(manager.getModeConfigId("code")).resolves.toBe("fresh-id") - await expect(provider["getModeConfigId"]("code")).resolves.toBe("fresh-id") + await expect(provider["getModeConfigId"]("architect")).resolves.toBe("shared-id") }) it("drops local choices and re-reads the mapping when state is reset", async () => { @@ -5987,7 +4685,6 @@ describe("ClineProvider", () => { vi.spyOn(provider, "postStateToWebview").mockResolvedValue(undefined) vi.spyOn(provider.providerSettingsManager, "getModeConfigIds").mockResolvedValue({ code: "reset-id" }) vi.spyOn(provider.providerSettingsManager, "getModeConfigId").mockResolvedValue(undefined) - existingProfiles("removed-profile-id", "reset-id") await provider["setModeConfig"]("code", "removed-profile-id") await provider.resetState() @@ -5996,7 +4693,7 @@ describe("ClineProvider", () => { }) }) - it("keeps current config without saving a shared default for an unmapped mode", async () => { + it("saves current config when switching to mode without config", async () => { await provider.resolveWebviewView(mockWebviewView) const messageHandler = (mockWebviewView.webview.onDidReceiveMessage as any).mock.calls[0][0] @@ -6015,8 +4712,8 @@ describe("ClineProvider", () => { // Switch to architect mode await messageHandler({ type: "mode", text: "architect" }) - // An implicit mode switch must not seed shared storage. - expect(provider.providerSettingsManager.setModeConfig).not.toHaveBeenCalled() + // Should save current config as default for architect mode + expect(provider.providerSettingsManager.setModeConfig).toHaveBeenCalledWith("architect", "current-id") }) it("saves config as default for current mode when loading config", async () => { @@ -6043,12 +4740,7 @@ describe("ClineProvider", () => { await messageHandler({ type: "loadApiConfiguration", text: "new-config" }) // Should save new config as default for architect mode - expect(provider.providerSettingsManager.setModeConfig).toHaveBeenCalledWith( - "architect", - "new-id", - expect.any(Function), - expect.any(AbortSignal), - ) + expect(provider.providerSettingsManager.setModeConfig).toHaveBeenCalledWith("architect", "new-id") }) it("load API configuration by ID works and updates mode config", async () => { @@ -6075,19 +4767,10 @@ describe("ClineProvider", () => { await messageHandler({ type: "loadApiConfigurationById", text: "config-id-123" }) // Should save new config as default for architect mode - expect(provider.providerSettingsManager.setModeConfig).toHaveBeenCalledWith( - "architect", - "config-id-123", - expect.any(Function), - expect.any(AbortSignal), - ) + expect(provider.providerSettingsManager.setModeConfig).toHaveBeenCalledWith("architect", "config-id-123") // Ensure the `activateProfile` method was called with the correct ID - expect(provider.providerSettingsManager.activateProfile).toHaveBeenCalledWith( - { id: "config-id-123" }, - expect.any(AbortSignal), - expect.any(Function), - ) + expect(provider.providerSettingsManager.activateProfile).toHaveBeenCalledWith({ id: "config-id-123" }) }) test("handles showRooIgnoredFiles setting", async () => { @@ -6264,12 +4947,7 @@ describe("ClineProvider", () => { }) // Should save config as default for current mode - expect(provider.providerSettingsManager.setModeConfig).toHaveBeenCalledWith( - "code", - "test-id", - expect.any(Function), - expect.any(AbortSignal), - ) + expect(provider.providerSettingsManager.setModeConfig).toHaveBeenCalledWith("code", "test-id") }) test("file content includes line numbers", async () => { @@ -6601,7 +5279,6 @@ describe("ClineProvider", () => { apiProvider: providerIdentifiers.anthropic, } - provider["initialModeConfigIds"] = Promise.resolve({ architect: "saved-config-id" }) ;(provider as any).providerSettingsManager = { getModeConfigId: vi.fn().mockResolvedValue("saved-config-id"), listConfig: vi.fn().mockResolvedValue([profile]), @@ -6617,19 +5294,15 @@ describe("ClineProvider", () => { expect(mockContext.globalState.update).toHaveBeenCalledWith("mode", "architect") // Verify saved config was loaded - expect(provider.providerSettingsManager.getModeConfigId).not.toHaveBeenCalled() - expect(provider.providerSettingsManager.activateProfile).toHaveBeenCalledWith( - { name: "saved-config" }, - expect.any(AbortSignal), - expect.any(Function), - ) + expect(provider.providerSettingsManager.getModeConfigId).toHaveBeenCalledWith("architect") + expect(provider.providerSettingsManager.activateProfile).toHaveBeenCalledWith({ name: "saved-config" }) expect(mockContext.globalState.update).toHaveBeenCalledWith("currentApiConfigName", "saved-config") // Verify state was posted to webview expect(mockPostMessage).toHaveBeenCalledWith(expect.objectContaining({ type: "state" })) }) - test("keeps current config without saving a shared default for an unmapped mode", async () => { + test("saves current config when switching to mode without config", async () => { ;(provider as any).providerSettingsManager = { getModeConfigId: vi.fn().mockResolvedValue(undefined), listConfig: vi @@ -6654,8 +5327,8 @@ describe("ClineProvider", () => { // Verify mode was updated expect(mockContext.globalState.update).toHaveBeenCalledWith("mode", "architect") - // An implicit mode switch must not seed shared storage. - expect(provider.providerSettingsManager.setModeConfig).not.toHaveBeenCalled() + // Verify current config was saved as default for new mode + expect(provider.providerSettingsManager.setModeConfig).toHaveBeenCalledWith("architect", "current-id") // Verify state was posted to webview expect(mockPostMessage).toHaveBeenCalledWith(expect.objectContaining({ type: "state" })) @@ -6756,7 +5429,6 @@ describe("ClineProvider", () => { }) // Mock provider settings manager - provider["initialModeConfigIds"] = Promise.resolve({ "custom-mode": "config-id" }) ;(provider as any).providerSettingsManager = { getModeConfigId: vi.fn().mockResolvedValue("config-id"), listConfig: vi @@ -6896,7 +5568,6 @@ describe("ClineProvider", () => { }) // Mock provider settings manager to throw error - provider["initialModeConfigIds"] = Promise.resolve({ code: "config-id" }) ;(provider as any).providerSettingsManager = { getModeConfigId: vi.fn().mockResolvedValue("config-id"), listConfig: vi @@ -7055,12 +5726,7 @@ describe("ClineProvider", () => { }) // Verify config was saved - expect(provider.providerSettingsManager.saveConfig).toHaveBeenCalledWith( - "test-config", - testApiConfig, - expect.any(AbortSignal), - expect.any(Function), - ) + expect(provider.providerSettingsManager.saveConfig).toHaveBeenCalledWith("test-config", testApiConfig) // Verify state updates expect(mockContext.globalState.update).toHaveBeenCalledWith("listApiConfigMeta", [ diff --git a/src/core/webview/__tests__/ClineProvider.sticky-mode.spec.ts b/src/core/webview/__tests__/ClineProvider.sticky-mode.spec.ts index 4d5553b417..47fcfd11f0 100644 --- a/src/core/webview/__tests__/ClineProvider.sticky-mode.spec.ts +++ b/src/core/webview/__tests__/ClineProvider.sticky-mode.spec.ts @@ -747,16 +747,12 @@ describe("ClineProvider - Sticky Mode", () => { const architectConfigId = provider.getProviderProfileEntry("architect-config")?.id // Associate configs with modes - await provider.setModeConfig("code", codeConfigId!) - await provider.setModeConfig("architect", architectConfigId!) + await provider.providerSettingsManager.setModeConfig("code", codeConfigId!) + await provider.providerSettingsManager.setModeConfig("architect", architectConfigId!) // Start in code mode with code config await provider.handleModeSwitch("code") - const stateBeforeRestore = await provider.getState() - expect(stateBeforeRestore.currentApiConfigName).toBe("code-config") - expect(stateBeforeRestore.apiConfiguration.apiProvider).toBe("anthropic") - // Create a history item with architect mode const historyItem: HistoryItem = { id: "test-task-id", @@ -771,18 +767,8 @@ describe("ClineProvider - Sticky Mode", () => { mode: "architect", // Task was created in architect mode } - // Another window changes the shared architect default after this window chose its profile. - await provider.providerSettingsManager.setModeConfig("architect", codeConfigId!) - const activate = vi.spyOn(provider.providerSettingsManager, "activateProfile") - // Restore the task from history await provider.createTaskWithHistoryItem(historyItem) - expect(activate).toHaveBeenCalledWith( - { name: "architect-config" }, - expect.any(AbortSignal), - expect.any(Function), - ) - await expect(provider.providerSettingsManager.getModeConfigId("architect")).resolves.toBe(codeConfigId) // Verify that the mode was restored const state = await provider.getState() diff --git a/src/core/webview/__tests__/ClineProvider.sticky-profile.spec.ts b/src/core/webview/__tests__/ClineProvider.sticky-profile.spec.ts index 39d8c6469e..11a3fafeaf 100644 --- a/src/core/webview/__tests__/ClineProvider.sticky-profile.spec.ts +++ b/src/core/webview/__tests__/ClineProvider.sticky-profile.spec.ts @@ -456,12 +456,7 @@ describe("ClineProvider - Sticky Provider Profile", () => { ) if (persistModeConfig) { - expect(setModeConfigSpy).toHaveBeenCalledExactlyOnceWith( - "architect", - "new-profile-id", - expect.any(Function), - expect.any(AbortSignal), - ) + expect(setModeConfigSpy).toHaveBeenCalledExactlyOnceWith("architect", "new-profile-id") } else { expect(setModeConfigSpy).not.toHaveBeenCalled() } @@ -1040,10 +1035,8 @@ describe("ClineProvider - Sticky Provider Profile", () => { // Mock log to verify error is logged const logSpy = vi.spyOn(provider, "log") - // A committed profile whose sticky history failed must report partial persistence. - await expect(provider.activateProviderProfile({ name: "new-profile" })).rejects.toThrow( - "Profile activation may be partially persisted: Save failed", - ) + // Switch provider profile - should not throw + await expect(provider.activateProviderProfile({ name: "new-profile" })).resolves.not.toThrow() // Verify error was logged expect(logSpy).toHaveBeenCalledWith(expect.stringContaining("Failed to persist provider profile switch")) diff --git a/src/eslint-suppressions.json b/src/eslint-suppressions.json index 91cd9b8888..ae3d504003 100644 --- a/src/eslint-suppressions.json +++ b/src/eslint-suppressions.json @@ -911,7 +911,7 @@ }, "core/webview/ClineProvider.ts": { "@typescript-eslint/no-explicit-any": { - "count": 6 + "count": 7 } }, "core/webview/__tests__/ClineProvider.apiHandlerRebuild.spec.ts": { diff --git a/src/extension.ts b/src/extension.ts index 1d01f206a6..34865230c4 100644 --- a/src/extension.ts +++ b/src/extension.ts @@ -288,7 +288,6 @@ export async function activate(context: vscode.ExtensionContext) { providerSettingsManager: provider.providerSettingsManager, contextProxy: provider.contextProxy, customModesManager: provider.customModesManager, - onModeConfigIdsImported: (ids) => provider.adoptModeConfigIds(ids), }) } catch (error) { outputChannel.appendLine( diff --git a/src/extension/__tests__/api-configuration.spec.ts b/src/extension/__tests__/api-configuration.spec.ts index 521a6a2de6..a10bfe60ac 100644 --- a/src/extension/__tests__/api-configuration.spec.ts +++ b/src/extension/__tests__/api-configuration.spec.ts @@ -4,7 +4,7 @@ import type * as vscode from "vscode" import type { RooCodeSettings } from "@roo-code/types" import { API } from "../api" -import { ClineProvider } from "../../core/webview/ClineProvider" +import type { ClineProvider } from "../../core/webview/ClineProvider" import { makeClineProviderFactory } from "../../test-utils/provider" vi.mock("@roo-code/ipc", () => ({ @@ -22,36 +22,15 @@ describe("API - configuration", () => { on: vi.fn(), log: vi.fn(), contextProxy: { setValues }, - providerSettingsManager: { - saveConfig, - setModeConfig, - listConfig: vi.fn().mockResolvedValue([ - { name: "code", id: "code-config" }, - { name: "custom", id: "architect-config" }, - ]), - }, - profileMutationAbortController: new AbortController(), - modeProfileState: { - reset: undefined, - activeMutationSignals: new Set(), - committingMutationSignals: new Set(), - }, - localModeConfigIds: new Map(), - modeConfigWriteOwners: new Map(), - modeConfigWrites: new Map>(), - initialModeConfigIds: Promise.resolve({}), - setModeConfig: ClineProvider.prototype.setModeConfig, - writeModeConfig: ClineProvider.prototype["writeModeConfig"], - getModeConfigId: ClineProvider.prototype["getModeConfigId"], + providerSettingsManager: { saveConfig, setModeConfig }, postStateToWebview, - // Provides the configuration methods and event registration used by API. } as unknown as ClineProvider const outputChannel = { appendLine: vi.fn() } as unknown as vscode.OutputChannel const api = new API(outputChannel, provider, makeClineProviderFactory()) await api.setConfiguration({ currentApiConfigName: "default", - modeApiConfigs: { code: "code-config", "new-custom-mode": "architect-config" }, + modeApiConfigs: { code: "code-config", architect: "architect-config" }, }) expect(saveConfig).toHaveBeenCalledWith("default", expect.objectContaining({ currentApiConfigName: "default" })) @@ -62,69 +41,11 @@ describe("API - configuration", () => { }), ) expect(setModeConfig).toHaveBeenCalledTimes(2) - expect(setModeConfig).toHaveBeenCalledWith("code", "code-config", expect.any(Function), expect.any(AbortSignal)) - expect(setModeConfig).toHaveBeenCalledWith( - "new-custom-mode", - "architect-config", - expect.any(Function), - expect.any(AbortSignal), - ) - await expect(provider["getModeConfigId"]("code")).resolves.toBe("code-config") - await expect(provider["getModeConfigId"]("new-custom-mode")).resolves.toBe("architect-config") + expect(setModeConfig).toHaveBeenCalledWith("code", "code-config") + expect(setModeConfig).toHaveBeenCalledWith("architect", "architect-config") expect(postStateToWebview).toHaveBeenCalledOnce() }) - it("reports partial persistence after all mode writes settle when reset cancels a mapping", async () => { - const setValues = vi.fn().mockResolvedValue(undefined) - const saveConfig = vi.fn().mockResolvedValue("default-id") - let release = () => {} - const pending = new Promise((resolve) => { - release = resolve - }) - const cancellationError = new Error("Mode profile write cancelled by settings reset") - const setModeConfig = vi - .fn() - .mockRejectedValueOnce(cancellationError) - .mockImplementationOnce(async () => { - await pending - }) - const postStateToWebview = vi.fn().mockResolvedValue(undefined) - // Supplies configuration persistence, profile storage, and the event hook used by API. - const provider = { - context: {}, - on: vi.fn(), - contextProxy: { setValues }, - providerSettingsManager: { saveConfig }, - setModeConfig, - postStateToWebview, - } as unknown as ClineProvider - // API only appends log lines to this output double. - const outputChannel = { appendLine: vi.fn() } as unknown as vscode.OutputChannel - const api = new API(outputChannel, provider, makeClineProviderFactory()) - const outcomes: string[] = [] - const updated = api - .setConfiguration({ - currentApiConfigName: "default", - modeApiConfigs: { code: "code-id", architect: "architect-id" }, - }) - .finally(() => { - outcomes.push("settled") - }) - const failure = updated.catch((error: unknown) => error) - const failed = expect(updated).rejects.toThrow("Configuration update may be partially persisted") - await vi.waitFor(() => expect(setModeConfig).toHaveBeenCalledTimes(2)) - expect(setValues).toHaveBeenCalledOnce() - expect(saveConfig).toHaveBeenCalledOnce() - expect(outcomes).toEqual([]) - release() - await failed - const error = await failure - expect(error).toBeInstanceOf(Error) - if (error instanceof Error) expect(error.cause).toBe(cancellationError) - - expect(postStateToWebview).not.toHaveBeenCalled() - }) - it("does not persist mode mappings when none are supplied", async () => { const setValues = vi.fn().mockResolvedValue(undefined) const saveConfig = vi.fn().mockResolvedValue("default-id") @@ -135,10 +56,8 @@ describe("API - configuration", () => { on: vi.fn(), log: vi.fn(), contextProxy: { setValues }, - providerSettingsManager: { saveConfig }, - setModeConfig, + providerSettingsManager: { saveConfig, setModeConfig }, postStateToWebview, - // Provides the configuration methods and event registration used by API. } as unknown as ClineProvider const outputChannel = { appendLine: vi.fn() } as unknown as vscode.OutputChannel const api = new API(outputChannel, provider, makeClineProviderFactory()) diff --git a/src/extension/api.ts b/src/extension/api.ts index 482856cae5..606bb7725d 100644 --- a/src/extension/api.ts +++ b/src/extension/api.ts @@ -655,20 +655,11 @@ export class API extends EventEmitter implements RooCodeAPI { await this.sidebarProvider.contextProxy.setValues(values) await this.sidebarProvider.providerSettingsManager.saveConfig(values.currentApiConfigName || "default", values) if (values.modeApiConfigs) { - const results = await Promise.allSettled( + await Promise.all( Object.entries(values.modeApiConfigs).map(([mode, configId]) => - this.sidebarProvider.setModeConfig(mode as Mode, configId), + this.sidebarProvider.providerSettingsManager.setModeConfig(mode as Mode, configId), ), ) - const failed = results.find((result): result is PromiseRejectedResult => result.status === "rejected") - if (failed) { - throw new Error( - "Configuration update may be partially persisted: mode profile mappings were not fully saved", - { - cause: failed.reason, - }, - ) - } } await this.sidebarProvider.postStateToWebview() } diff --git a/src/utils/autoImportSettings.ts b/src/utils/autoImportSettings.ts index 511bec72c3..3c8773fb6b 100644 --- a/src/utils/autoImportSettings.ts +++ b/src/utils/autoImportSettings.ts @@ -15,7 +15,7 @@ import { importSettingsFromPath, ImportOptions } from "../core/config/importExpo */ export async function autoImportSettings( outputChannel: vscode.OutputChannel, - { providerSettingsManager, contextProxy, customModesManager, onModeConfigIdsImported }: ImportOptions, + { providerSettingsManager, contextProxy, customModesManager }: ImportOptions, ): Promise { try { // Get the auto-import settings path from VSCode settings @@ -41,7 +41,6 @@ export async function autoImportSettings( providerSettingsManager, contextProxy, customModesManager, - onModeConfigIdsImported, }) if (result.success) { From e203e7bd928fbc68a7aabbb883c3dd64c1966c83 Mon Sep 17 00:00:00 2001 From: Elliott de Launay Date: Thu, 12 Nov 2026 01:18:09 +0000 Subject: [PATCH 25/30] fix(profiles): preserve cache integrity and route API mode choices locally --- src/core/webview/ClineProvider.ts | 15 ++++---- .../webview/__tests__/ClineProvider.spec.ts | 34 +++++++++++++++++++ .../ClineProvider.sticky-profile.spec.ts | 1 + .../__tests__/api-configuration.spec.ts | 6 ++-- src/extension/api.ts | 2 +- 5 files changed, 47 insertions(+), 11 deletions(-) diff --git a/src/core/webview/ClineProvider.ts b/src/core/webview/ClineProvider.ts index 16d4d0aca0..36974c623b 100644 --- a/src/core/webview/ClineProvider.ts +++ b/src/core/webview/ClineProvider.ts @@ -2175,17 +2175,16 @@ export class ClineProvider } private async getModeConfigId(mode: Mode): Promise { - return ( - this.localModeConfigIds.get(mode) ?? - (await this.initialModeConfigIds)[mode] ?? - // Modes created after this window opened have no snapshot entry. - (await this.providerSettingsManager.getModeConfigId(mode)) - ) + const cachedId = this.localModeConfigIds.get(mode) ?? (await this.initialModeConfigIds)[mode] + if (cachedId && (await this.providerSettingsManager.listConfig()).some(({ id }) => id === cachedId)) { + return cachedId + } + return this.providerSettingsManager.getModeConfigId(mode) } - private async setModeConfig(mode: Mode, id: string): Promise { - this.localModeConfigIds.set(mode, id) + public async setModeConfig(mode: Mode, id: string): Promise { await this.providerSettingsManager.setModeConfig(mode, id) + this.localModeConfigIds.set(mode, id) } /** diff --git a/src/core/webview/__tests__/ClineProvider.spec.ts b/src/core/webview/__tests__/ClineProvider.spec.ts index b529248867..aec23df539 100644 --- a/src/core/webview/__tests__/ClineProvider.spec.ts +++ b/src/core/webview/__tests__/ClineProvider.spec.ts @@ -4638,6 +4638,8 @@ describe("ClineProvider", () => { vi.spyOn(manager, "getModeConfigId").mockResolvedValue("other-window-id") vi.spyOn(manager, "setModeConfig").mockResolvedValue(undefined) + vi.spyOn(manager, "listConfig").mockResolvedValue([{ name: "local", id: "this-window-id" }]) + await provider["setModeConfig"]("code", "this-window-id") expect(manager.setModeConfig).toHaveBeenCalledWith("code", "this-window-id") @@ -4647,6 +4649,38 @@ describe("ClineProvider", () => { }) describe("mode profile snapshot", () => { + beforeEach(() => { + vi.spyOn(provider.providerSettingsManager, "listConfig").mockResolvedValue( + ["opened-with-id", "chosen-id", "reset-id"].map((id) => ({ name: id, id })), + ) + }) + + it("keeps the prior choice when the shared write fails", async () => { + provider["initialModeConfigIds"] = Promise.resolve({ code: "opened-with-id" }) + const error = new Error("write failed") + vi.spyOn(provider.providerSettingsManager, "setModeConfig").mockRejectedValue(error) + + await expect(provider.setModeConfig("code", "failed-id")).rejects.toBe(error) + await expect(provider["getModeConfigId"]("code")).resolves.toBe("opened-with-id") + }) + + it("returns undefined when no mapping exists", async () => { + vi.spyOn(provider.providerSettingsManager, "getModeConfigId").mockResolvedValue(undefined) + + await expect(provider["getModeConfigId"]("new-custom-mode")).resolves.toBeUndefined() + }) + + it.each(["local", "snapshot"])("ignores a stale %s ID after another window resets profiles", async (source) => { + if (source === "local") { + provider["localModeConfigIds"].set("code", "removed-id") + } else { + provider["initialModeConfigIds"] = Promise.resolve({ code: "removed-id" }) + } + vi.spyOn(provider.providerSettingsManager, "getModeConfigId").mockResolvedValue("reset-id") + + await expect(provider["getModeConfigId"]("code")).resolves.toBe("reset-id") + }) + it("keeps the choice this window opened with when another window changes the shared value", async () => { provider["initialModeConfigIds"] = Promise.resolve({ architect: "opened-with-id" }) vi.spyOn(provider.providerSettingsManager, "getModeConfigId").mockResolvedValue("other-window-id") diff --git a/src/core/webview/__tests__/ClineProvider.sticky-profile.spec.ts b/src/core/webview/__tests__/ClineProvider.sticky-profile.spec.ts index 11a3fafeaf..60b5cde8fd 100644 --- a/src/core/webview/__tests__/ClineProvider.sticky-profile.spec.ts +++ b/src/core/webview/__tests__/ClineProvider.sticky-profile.spec.ts @@ -699,6 +699,7 @@ describe("ClineProvider - Sticky Provider Profile", () => { }) it("restores the mode-based profile without persisting it as a mode default or touching another task", async () => { + provider["initialModeConfigIds"] = Promise.resolve({ code: "mode-config-id" }) await provider.resolveWebviewView(mockWebviewView) const historyItem: HistoryItem = { id: "test-task-id", diff --git a/src/extension/__tests__/api-configuration.spec.ts b/src/extension/__tests__/api-configuration.spec.ts index a10bfe60ac..6f263ab9f6 100644 --- a/src/extension/__tests__/api-configuration.spec.ts +++ b/src/extension/__tests__/api-configuration.spec.ts @@ -22,7 +22,8 @@ describe("API - configuration", () => { on: vi.fn(), log: vi.fn(), contextProxy: { setValues }, - providerSettingsManager: { saveConfig, setModeConfig }, + providerSettingsManager: { saveConfig }, + setModeConfig, postStateToWebview, } as unknown as ClineProvider const outputChannel = { appendLine: vi.fn() } as unknown as vscode.OutputChannel @@ -56,7 +57,8 @@ describe("API - configuration", () => { on: vi.fn(), log: vi.fn(), contextProxy: { setValues }, - providerSettingsManager: { saveConfig, setModeConfig }, + providerSettingsManager: { saveConfig }, + setModeConfig, postStateToWebview, } as unknown as ClineProvider const outputChannel = { appendLine: vi.fn() } as unknown as vscode.OutputChannel diff --git a/src/extension/api.ts b/src/extension/api.ts index 606bb7725d..15be22d774 100644 --- a/src/extension/api.ts +++ b/src/extension/api.ts @@ -657,7 +657,7 @@ export class API extends EventEmitter implements RooCodeAPI { if (values.modeApiConfigs) { await Promise.all( Object.entries(values.modeApiConfigs).map(([mode, configId]) => - this.sidebarProvider.providerSettingsManager.setModeConfig(mode as Mode, configId), + this.sidebarProvider.setModeConfig(mode as Mode, configId), ), ) } From e7ed88f433c381e0ef09b6dbfdbc32e45eaab4b6 Mon Sep 17 00:00:00 2001 From: Elliott de Launay Date: Thu, 12 Nov 2026 01:53:00 +0000 Subject: [PATCH 26/30] fix(profiles): refresh window mode choices when profiles are imported --- src/core/config/ProviderSettingsManager.ts | 10 +- src/core/webview/ClineProvider.ts | 6 +- .../webview/__tests__/ClineProvider.spec.ts | 109 ++++++++++++++++++ 3 files changed, 122 insertions(+), 3 deletions(-) diff --git a/src/core/config/ProviderSettingsManager.ts b/src/core/config/ProviderSettingsManager.ts index a355b2ff01..79a9d67c79 100644 --- a/src/core/config/ProviderSettingsManager.ts +++ b/src/core/config/ProviderSettingsManager.ts @@ -80,7 +80,10 @@ export class ProviderSettingsManager { private readonly context: ExtensionContext - constructor(context: ExtensionContext) { + constructor( + context: ExtensionContext, + private readonly onImport?: (modeConfigIds: Record) => void, + ) { this.context = context // TODO: We really shouldn't have async methods in the constructor. @@ -653,7 +656,10 @@ export class ProviderSettingsManager { public async import(providerProfiles: ProviderProfiles) { try { - return await this.lock(() => this.store(providerProfiles)) + await this.lock(async () => { + await this.store(providerProfiles) + this.onImport?.({ ...providerProfiles.modeApiConfigs }) + }) } catch (error) { throw new Error(`Failed to import provider profiles: ${error}`) } diff --git a/src/core/webview/ClineProvider.ts b/src/core/webview/ClineProvider.ts index 36974c623b..35d660e61a 100644 --- a/src/core/webview/ClineProvider.ts +++ b/src/core/webview/ClineProvider.ts @@ -471,7 +471,11 @@ export class ClineProvider this._workspaceTracker = new WorkspaceTracker(this) - this.providerSettingsManager = new ProviderSettingsManager(this.context) + this.providerSettingsManager = new ProviderSettingsManager(this.context, (modeConfigIds) => { + // Manual and automatic imports replace this provider's previous mode choices. + this.localModeConfigIds.clear() + this.initialModeConfigIds = Promise.resolve(modeConfigIds) + }) this.captureInitialModeConfigIds() this.customModesManager = new CustomModesManager(this.context, async () => { diff --git a/src/core/webview/__tests__/ClineProvider.spec.ts b/src/core/webview/__tests__/ClineProvider.spec.ts index aec23df539..97403ff56e 100644 --- a/src/core/webview/__tests__/ClineProvider.spec.ts +++ b/src/core/webview/__tests__/ClineProvider.spec.ts @@ -1,6 +1,7 @@ // pnpm --filter roo-cline test core/webview/__tests__/ClineProvider.spec.ts import fs from "fs" +import fsPromises from "fs/promises" import * as path from "path" import { TaskRegistry } from "../../task/TaskRegistry" @@ -30,6 +31,8 @@ import { defaultModeSlug } from "../../../shared/modes" import { experimentDefault } from "../../../shared/experiments" import { setTtsEnabled } from "../../../utils/tts" import { ContextProxy } from "../../config/ContextProxy" +import { ProviderSettingsManager } from "../../config/ProviderSettingsManager" +import { importSettingsFromPath } from "../../config/importExport" import { WorkspaceIndexingEnablementManager } from "../../../services/code-index/workspace-indexing-enablement-manager" import { Task, TaskOptions } from "../../task/Task" import { safeWriteJson } from "../../../utils/safeWriteJson" @@ -4648,6 +4651,112 @@ describe("ClineProvider", () => { await expect(provider["getModeConfigId"]("architect")).resolves.toBe("other-window-id") }) + describe("mode profile initialization and imports", () => { + const profiles = { + currentApiConfigName: "first", + apiConfigs: { first: { id: "id1" }, second: { id: "id2" }, imported: { id: "id3" } }, + modeApiConfigs: { code: "id1", architect: "id1" }, + } + let createdProviders: ClineProvider[] + + const newProvider = () => { + const created = new ClineProvider( + mockContext, + mockOutputChannel, + "sidebar", + new ContextProxy(mockContext), + new WebviewFocusTracker(), + ) + createdProviders.push(created) + return created + } + + beforeEach(async () => { + createdProviders = [] + await provider.providerSettingsManager.import(profiles) + }) + + afterEach(async () => { + for (const created of createdProviders) { + await created.dispose() + } + vi.restoreAllMocks() + }) + + it("captures the opening snapshot during construction and waits for it on lookup", async () => { + let resolveSnapshot!: (value: Record) => void + const snapshot = new Promise>((resolve) => { + resolveSnapshot = resolve + }) + const getSnapshot = vi + .spyOn(ProviderSettingsManager.prototype, "getModeConfigIds") + .mockReturnValue(snapshot) + const created = newProvider() + expect(getSnapshot).toHaveBeenCalledOnce() + + let settled = false + const lookup = created["getModeConfigId"]("code").then((id) => { + settled = true + return id + }) + // Flush the real manager's initialization while the opening snapshot is pending. + await created.providerSettingsManager.listConfig() + expect(settled).toBe(false) + + resolveSnapshot({ code: "id2" }) + await expect(lookup).resolves.toBe("id2") + expect(getSnapshot).toHaveBeenCalledOnce() + }) + + it("isolates two providers using the same shared profile store", async () => { + const first = newProvider() + const second = newProvider() + await Promise.all([first["initialModeConfigIds"], second["initialModeConfigIds"]]) + + await first.setModeConfig("code", "id2") + + await expect(second.providerSettingsManager.getModeConfigId("code")).resolves.toBe("id2") + await expect(first["getModeConfigId"]("code")).resolves.toBe("id2") + await expect(second["getModeConfigId"]("code")).resolves.toBe("id1") + }) + + it.each(["success", "profile write fails", "later settings write fails"])( + "refreshes imported local and snapshot choices only after profiles persist: %s", + async (outcome) => { + const first = newProvider() + const second = newProvider() + await Promise.all([first["initialModeConfigIds"], second["initialModeConfigIds"]]) + await first.setModeConfig("code", "id2") + vi.mocked(fsPromises.readFile).mockResolvedValueOnce( + JSON.stringify({ + providerProfiles: { ...profiles, modeApiConfigs: { code: "id3", architect: "id3" } }, + globalSettings: {}, + }), + ) + if (outcome === "profile write fails") { + vi.spyOn(mockContext.secrets, "store").mockRejectedValueOnce(new Error("profile write failed")) + } else if (outcome === "later settings write fails") { + vi.spyOn(first.contextProxy, "setValues").mockRejectedValueOnce(new Error("settings write failed")) + } + + const result = await importSettingsFromPath("/test/settings.json", { + providerSettingsManager: first.providerSettingsManager, + contextProxy: first.contextProxy, + customModesManager: first.customModesManager, + }) + + expect(result.success).toBe(outcome === "success") + await expect(first["getModeConfigId"]("code")).resolves.toBe( + outcome === "profile write fails" ? "id2" : "id3", + ) + await expect(first["getModeConfigId"]("architect")).resolves.toBe( + outcome === "profile write fails" ? "id1" : "id3", + ) + await expect(second["getModeConfigId"]("code")).resolves.toBe("id1") + }, + ) + }) + describe("mode profile snapshot", () => { beforeEach(() => { vi.spyOn(provider.providerSettingsManager, "listConfig").mockResolvedValue( From 588379872083d16de73565b2fc1ec554724b498c Mon Sep 17 00:00:00 2001 From: Elliott de Launay Date: Thu, 12 Nov 2026 02:18:50 +0000 Subject: [PATCH 27/30] test(profiles): retain imported choices after another provider writes --- src/core/webview/__tests__/ClineProvider.spec.ts | 6 ++++++ 1 file changed, 6 insertions(+) diff --git a/src/core/webview/__tests__/ClineProvider.spec.ts b/src/core/webview/__tests__/ClineProvider.spec.ts index 97403ff56e..4697323b51 100644 --- a/src/core/webview/__tests__/ClineProvider.spec.ts +++ b/src/core/webview/__tests__/ClineProvider.spec.ts @@ -4753,6 +4753,12 @@ describe("ClineProvider", () => { outcome === "profile write fails" ? "id1" : "id3", ) await expect(second["getModeConfigId"]("code")).resolves.toBe("id1") + if (outcome !== "profile write fails") { + await second.setModeConfig("code", "id2") + await second.setModeConfig("architect", "id2") + await expect(first["getModeConfigId"]("code")).resolves.toBe("id3") + await expect(first["getModeConfigId"]("architect")).resolves.toBe("id3") + } }, ) }) From b89193e7b035be3070630d144ce800935865a4a0 Mon Sep 17 00:00:00 2001 From: Elliott de Launay Date: Thu, 12 Nov 2026 02:38:10 +0000 Subject: [PATCH 28/30] fix(profiles): keep unmapped modes isolated from later shared choices --- src/core/webview/ClineProvider.ts | 4 ++- .../ClineProvider.apiHandlerRebuild.spec.ts | 3 +- .../ClineProvider.lockApiConfig.spec.ts | 5 +-- .../webview/__tests__/ClineProvider.spec.ts | 36 +++++++++++++------ 4 files changed, 34 insertions(+), 14 deletions(-) diff --git a/src/core/webview/ClineProvider.ts b/src/core/webview/ClineProvider.ts index 35d660e61a..bff7c31a7a 100644 --- a/src/core/webview/ClineProvider.ts +++ b/src/core/webview/ClineProvider.ts @@ -2180,7 +2180,9 @@ export class ClineProvider private async getModeConfigId(mode: Mode): Promise { const cachedId = this.localModeConfigIds.get(mode) ?? (await this.initialModeConfigIds)[mode] - if (cachedId && (await this.providerSettingsManager.listConfig()).some(({ id }) => id === cachedId)) { + // An unmapped mode keeps this provider's current profile, even if another window maps it later. + if (!cachedId) return undefined + if ((await this.providerSettingsManager.listConfig()).some(({ id }) => id === cachedId)) { return cachedId } return this.providerSettingsManager.getModeConfigId(mode) diff --git a/src/core/webview/__tests__/ClineProvider.apiHandlerRebuild.spec.ts b/src/core/webview/__tests__/ClineProvider.apiHandlerRebuild.spec.ts index 3d8beb72fa..28531e964d 100644 --- a/src/core/webview/__tests__/ClineProvider.apiHandlerRebuild.spec.ts +++ b/src/core/webview/__tests__/ClineProvider.apiHandlerRebuild.spec.ts @@ -239,7 +239,7 @@ describe("ClineProvider - API Handler Rebuild Guard", () => { new ContextProxy(mockContext), new WebviewFocusTracker(), ) - // These tests stub providerSettingsManager and expect it to be consulted for mode profiles. + // Start without the snapshot from initial fixture storage; profile tests seed their own mapping. provider["initialModeConfigIds"] = Promise.resolve({}) // Mock providerSettingsManager @@ -969,6 +969,7 @@ describe("ClineProvider - API Handler Rebuild Guard", () => { }) test("fan-out preparation leaves the focused task untouched", async () => { + provider["initialModeConfigIds"] = Promise.resolve({ ask: "ask-id" }) const mockTask = new Task({ ...defaultTaskOptions, apiConfiguration: { diff --git a/src/core/webview/__tests__/ClineProvider.lockApiConfig.spec.ts b/src/core/webview/__tests__/ClineProvider.lockApiConfig.spec.ts index 62514466cb..abced7bd61 100644 --- a/src/core/webview/__tests__/ClineProvider.lockApiConfig.spec.ts +++ b/src/core/webview/__tests__/ClineProvider.lockApiConfig.spec.ts @@ -331,7 +331,7 @@ describe("ClineProvider - Lock API Config Across Modes", () => { new ContextProxy(mockContext), new WebviewFocusTracker(), ) - // These tests stub providerSettingsManager and expect it to be consulted for mode profiles. + // Start without the snapshot from initial fixture storage; profile tests seed their own mapping. provider["initialModeConfigIds"] = Promise.resolve({}) // Mock getMcpHub method @@ -374,6 +374,7 @@ describe("ClineProvider - Lock API Config Across Modes", () => { }) it("keeps normal mode-specific lookup/load behavior when lockApiConfigAcrossModes is false", async () => { + provider["initialModeConfigIds"] = Promise.resolve({ architect: "architect-profile-id" }) await mockContext.workspaceState.update("lockApiConfigAcrossModes", false) const getModeConfigIdSpy = vi @@ -394,7 +395,7 @@ describe("ClineProvider - Lock API Config Across Modes", () => { await provider.handleModeSwitch("architect") - expect(getModeConfigIdSpy).toHaveBeenCalledWith("architect") + expect(getModeConfigIdSpy).not.toHaveBeenCalled() expect(activateProfileSpy).toHaveBeenCalledWith({ name: "architect-profile" }) }) }) diff --git a/src/core/webview/__tests__/ClineProvider.spec.ts b/src/core/webview/__tests__/ClineProvider.spec.ts index 4697323b51..f78f7ff393 100644 --- a/src/core/webview/__tests__/ClineProvider.spec.ts +++ b/src/core/webview/__tests__/ClineProvider.spec.ts @@ -562,8 +562,7 @@ describe("ClineProvider", () => { new ContextProxy(mockContext), new WebviewFocusTracker(), ) - // Most tests stub providerSettingsManager and expect it to be consulted for mode profiles, - // so start without the snapshot the real manager would take of the seeded mode map. + // Start without the snapshot from initial fixture storage; profile tests seed their own mapping. provider["initialModeConfigIds"] = Promise.resolve({}) defaultTaskOptions = { @@ -4617,6 +4616,7 @@ describe("ClineProvider", () => { apiProvider: providerIdentifiers.anthropic, } + provider["initialModeConfigIds"] = Promise.resolve({ architect: "test-id" }) ;(provider as any).providerSettingsManager = { getModeConfigId: vi.fn().mockResolvedValue("test-id"), listConfig: vi.fn().mockResolvedValue([profile]), @@ -4629,7 +4629,7 @@ describe("ClineProvider", () => { await messageHandler({ type: "mode", text: "architect" }) // Should load the saved config for architect mode - expect(provider.providerSettingsManager.getModeConfigId).toHaveBeenCalledWith("architect") + expect(provider.providerSettingsManager.getModeConfigId).not.toHaveBeenCalled() expect(provider.providerSettingsManager.activateProfile).toHaveBeenCalledWith({ name: "test-config" }) expect(mockContext.globalState.update).toHaveBeenCalledWith("currentApiConfigName", "test-config") }) @@ -4647,8 +4647,8 @@ describe("ClineProvider", () => { expect(manager.setModeConfig).toHaveBeenCalledWith("code", "this-window-id") await expect(provider["getModeConfigId"]("code")).resolves.toBe("this-window-id") - // A mode this window never chose still falls back to the shared value. - await expect(provider["getModeConfigId"]("architect")).resolves.toBe("other-window-id") + // An unmapped mode keeps this provider's current profile. + await expect(provider["getModeConfigId"]("architect")).resolves.toBeUndefined() }) describe("mode profile initialization and imports", () => { @@ -4720,6 +4720,19 @@ describe("ClineProvider", () => { await expect(second["getModeConfigId"]("code")).resolves.toBe("id1") }) + it("keeps an unmapped mode local when another provider saves a mapping later", async () => { + const first = newProvider() + const second = newProvider() + await Promise.all([first["initialModeConfigIds"], second["initialModeConfigIds"]]) + + await second.setModeConfig("new-mode", "id2") + + await expect(first.providerSettingsManager.getModeConfigId("new-mode")).resolves.toBe("id2") + await expect(first["getModeConfigId"]("new-mode")).resolves.toBeUndefined() + await expect(second["getModeConfigId"]("new-mode")).resolves.toBe("id2") + await expect(newProvider()["getModeConfigId"]("new-mode")).resolves.toBe("id2") + }) + it.each(["success", "profile write fails", "later settings write fails"])( "refreshes imported local and snapshot choices only after profiles persist: %s", async (outcome) => { @@ -4801,8 +4814,8 @@ describe("ClineProvider", () => { vi.spyOn(provider.providerSettingsManager, "getModeConfigId").mockResolvedValue("other-window-id") await expect(provider["getModeConfigId"]("architect")).resolves.toBe("opened-with-id") - // A mode created after this window opened has no snapshot entry, so the shared value applies. - await expect(provider["getModeConfigId"]("new-custom-mode")).resolves.toBe("other-window-id") + // A mode created after this window opened keeps this provider's current profile. + await expect(provider["getModeConfigId"]("new-custom-mode")).resolves.toBeUndefined() }) it("prefers an explicit local choice over the snapshot", async () => { @@ -4814,13 +4827,13 @@ describe("ClineProvider", () => { await expect(provider["getModeConfigId"]("architect")).resolves.toBe("chosen-id") }) - it("falls back to the shared value when the snapshot cannot be read", async () => { + it("keeps the current profile when the snapshot cannot be read", async () => { vi.spyOn(provider.providerSettingsManager, "getModeConfigIds").mockRejectedValue(new Error("unreadable")) vi.spyOn(provider.providerSettingsManager, "getModeConfigId").mockResolvedValue("shared-id") provider["captureInitialModeConfigIds"]() - await expect(provider["getModeConfigId"]("architect")).resolves.toBe("shared-id") + await expect(provider["getModeConfigId"]("architect")).resolves.toBeUndefined() }) it("drops local choices and re-reads the mapping when state is reset", async () => { @@ -5428,6 +5441,7 @@ describe("ClineProvider", () => { apiProvider: providerIdentifiers.anthropic, } + provider["initialModeConfigIds"] = Promise.resolve({ architect: "saved-config-id" }) ;(provider as any).providerSettingsManager = { getModeConfigId: vi.fn().mockResolvedValue("saved-config-id"), listConfig: vi.fn().mockResolvedValue([profile]), @@ -5443,7 +5457,7 @@ describe("ClineProvider", () => { expect(mockContext.globalState.update).toHaveBeenCalledWith("mode", "architect") // Verify saved config was loaded - expect(provider.providerSettingsManager.getModeConfigId).toHaveBeenCalledWith("architect") + expect(provider.providerSettingsManager.getModeConfigId).not.toHaveBeenCalled() expect(provider.providerSettingsManager.activateProfile).toHaveBeenCalledWith({ name: "saved-config" }) expect(mockContext.globalState.update).toHaveBeenCalledWith("currentApiConfigName", "saved-config") @@ -5552,6 +5566,7 @@ describe("ClineProvider", () => { }) test("preserves mode when it exists in custom modes", async () => { + provider["initialModeConfigIds"] = Promise.resolve({ "custom-mode": "config-id" }) await provider.resolveWebviewView(mockWebviewView) // Mock custom modes that include the saved mode @@ -5698,6 +5713,7 @@ describe("ClineProvider", () => { }) test("continues with task restoration even if mode config loading fails", async () => { + provider["initialModeConfigIds"] = Promise.resolve({ code: "config-id" }) await provider.resolveWebviewView(mockWebviewView) // Mock custom modes From 3425536be92c72a36b678b1c0d54c41c65d2a35d Mon Sep 17 00:00:00 2001 From: Elliott de Launay Date: Thu, 12 Nov 2026 02:49:33 +0000 Subject: [PATCH 29/30] fix(profiles): keep implicit mode defaults local to the provider --- src/core/webview/ClineProvider.ts | 4 ++-- src/core/webview/__tests__/ClineProvider.spec.ts | 16 ++++++++++------ 2 files changed, 12 insertions(+), 8 deletions(-) diff --git a/src/core/webview/ClineProvider.ts b/src/core/webview/ClineProvider.ts index bff7c31a7a..81dc935377 100644 --- a/src/core/webview/ClineProvider.ts +++ b/src/core/webview/ClineProvider.ts @@ -2152,14 +2152,14 @@ export class ClineProvider // The task will continue with the current/default configuration. } } else { - // If no saved config for this mode, save current config as default. + // Keep an unmapped mode's default local; another window may already have saved a shared choice. const currentApiConfigNameAfter = this.getGlobalState("currentApiConfigName") if (currentApiConfigNameAfter) { const config = listApiConfig.find((c) => c.name === currentApiConfigNameAfter) if (config?.id) { - await this.setModeConfig(newMode, config.id) + this.localModeConfigIds.set(newMode, config.id) } } } diff --git a/src/core/webview/__tests__/ClineProvider.spec.ts b/src/core/webview/__tests__/ClineProvider.spec.ts index f78f7ff393..e198632db6 100644 --- a/src/core/webview/__tests__/ClineProvider.spec.ts +++ b/src/core/webview/__tests__/ClineProvider.spec.ts @@ -4730,6 +4730,10 @@ describe("ClineProvider", () => { await expect(first.providerSettingsManager.getModeConfigId("new-mode")).resolves.toBe("id2") await expect(first["getModeConfigId"]("new-mode")).resolves.toBeUndefined() await expect(second["getModeConfigId"]("new-mode")).resolves.toBe("id2") + await first.contextProxy.setValue("currentApiConfigName", "first") + await first.handleModeSwitch("new-mode") + await expect(first["getModeConfigId"]("new-mode")).resolves.toBe("id1") + await expect(second.providerSettingsManager.getModeConfigId("new-mode")).resolves.toBe("id2") await expect(newProvider()["getModeConfigId"]("new-mode")).resolves.toBe("id2") }) @@ -4855,7 +4859,7 @@ describe("ClineProvider", () => { }) }) - it("saves current config when switching to mode without config", async () => { + it("keeps the current config locally when switching to a mode without a config", async () => { await provider.resolveWebviewView(mockWebviewView) const messageHandler = (mockWebviewView.webview.onDidReceiveMessage as any).mock.calls[0][0] @@ -4874,8 +4878,8 @@ describe("ClineProvider", () => { // Switch to architect mode await messageHandler({ type: "mode", text: "architect" }) - // Should save current config as default for architect mode - expect(provider.providerSettingsManager.setModeConfig).toHaveBeenCalledWith("architect", "current-id") + await expect(provider["getModeConfigId"]("architect")).resolves.toBe("current-id") + expect(provider.providerSettingsManager.setModeConfig).not.toHaveBeenCalled() }) it("saves config as default for current mode when loading config", async () => { @@ -5465,7 +5469,7 @@ describe("ClineProvider", () => { expect(mockPostMessage).toHaveBeenCalledWith(expect.objectContaining({ type: "state" })) }) - test("saves current config when switching to mode without config", async () => { + test("keeps the current config locally when switching to a mode without a config", async () => { ;(provider as any).providerSettingsManager = { getModeConfigId: vi.fn().mockResolvedValue(undefined), listConfig: vi @@ -5490,8 +5494,8 @@ describe("ClineProvider", () => { // Verify mode was updated expect(mockContext.globalState.update).toHaveBeenCalledWith("mode", "architect") - // Verify current config was saved as default for new mode - expect(provider.providerSettingsManager.setModeConfig).toHaveBeenCalledWith("architect", "current-id") + await expect(provider["getModeConfigId"]("architect")).resolves.toBe("current-id") + expect(provider.providerSettingsManager.setModeConfig).not.toHaveBeenCalled() // Verify state was posted to webview expect(mockPostMessage).toHaveBeenCalledWith(expect.objectContaining({ type: "state" })) From a856b57c23576f690d871c794c61df8736cf16fd Mon Sep 17 00:00:00 2001 From: Elliott de Launay Date: Thu, 12 Nov 2026 14:21:17 +0000 Subject: [PATCH 30/30] fix(profiles): avoid persisting mappings when switching modes --- src/core/webview/ClineProvider.ts | 2 +- src/core/webview/__tests__/ClineProvider.spec.ts | 6 ++++++ 2 files changed, 7 insertions(+), 1 deletion(-) diff --git a/src/core/webview/ClineProvider.ts b/src/core/webview/ClineProvider.ts index 81dc935377..24b3ee2b9f 100644 --- a/src/core/webview/ClineProvider.ts +++ b/src/core/webview/ClineProvider.ts @@ -2142,7 +2142,7 @@ export class ClineProvider if (hasActualSettings) { await this.activateProviderProfileUnlocked( { name: profile.name }, - targetTask === null ? { skipCurrentTaskRebuild: true } : undefined, + { persistModeConfig: false, skipCurrentTaskRebuild: targetTask === null }, signal, ) } else { diff --git a/src/core/webview/__tests__/ClineProvider.spec.ts b/src/core/webview/__tests__/ClineProvider.spec.ts index e198632db6..52f79de031 100644 --- a/src/core/webview/__tests__/ClineProvider.spec.ts +++ b/src/core/webview/__tests__/ClineProvider.spec.ts @@ -4721,6 +4721,10 @@ describe("ClineProvider", () => { }) it("keeps an unmapped mode local when another provider saves a mapping later", async () => { + await provider.providerSettingsManager.saveConfig("first", { + id: "id1", + apiProvider: providerIdentifiers.openrouter, + }) const first = newProvider() const second = newProvider() await Promise.all([first["initialModeConfigIds"], second["initialModeConfigIds"]]) @@ -4732,6 +4736,8 @@ describe("ClineProvider", () => { await expect(second["getModeConfigId"]("new-mode")).resolves.toBe("id2") await first.contextProxy.setValue("currentApiConfigName", "first") await first.handleModeSwitch("new-mode") + await first.handleModeSwitch("code") + await first.handleModeSwitch("new-mode") await expect(first["getModeConfigId"]("new-mode")).resolves.toBe("id1") await expect(second.providerSettingsManager.getModeConfigId("new-mode")).resolves.toBe("id2") await expect(newProvider()["getModeConfigId"]("new-mode")).resolves.toBe("id2")