diff --git a/src/__tests__/ClineProvider.delegation.spec.ts b/src/__tests__/ClineProvider.delegation.spec.ts index eceb4cbeb0..a1a16d9284 100644 --- a/src/__tests__/ClineProvider.delegation.spec.ts +++ b/src/__tests__/ClineProvider.delegation.spec.ts @@ -294,6 +294,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 @@ -325,6 +327,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 }, { @@ -346,6 +395,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(), @@ -355,10 +405,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 diff --git a/src/core/config/ProviderSettingsManager.ts b/src/core/config/ProviderSettingsManager.ts index 01695d7994..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. @@ -574,6 +577,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 () => { @@ -638,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/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 6cec3bdbe7..24b3ee2b9f 100644 --- a/src/core/webview/ClineProvider.ts +++ b/src/core/webview/ClineProvider.ts @@ -421,6 +421,20 @@ 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() + + /** + * 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, @@ -457,7 +471,12 @@ 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 () => { await this.postStateToWebviewWithoutClineMessages() @@ -1493,7 +1512,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. @@ -2098,7 +2117,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 @@ -2123,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 { @@ -2133,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.providerSettingsManager.setModeConfig(newMode, config.id) + this.localModeConfigIds.set(newMode, config.id) } } } @@ -2152,6 +2171,28 @@ 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 { + const cachedId = this.localModeConfigIds.get(mode) ?? (await this.initialModeConfigIds)[mode] + // 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) + } + + public async setModeConfig(mode: Mode, id: string): Promise { + await this.providerSettingsManager.setModeConfig(mode, id) + this.localModeConfigIds.set(mode, id) + } + /** * Updates the current task's API handler. * Rebuilds when: @@ -2357,7 +2398,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( @@ -2482,7 +2523,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. @@ -3745,6 +3786,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() @@ -4760,7 +4804,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.apiHandlerRebuild.spec.ts b/src/core/webview/__tests__/ClineProvider.apiHandlerRebuild.spec.ts index c2aec90dcd..28531e964d 100644 --- a/src/core/webview/__tests__/ClineProvider.apiHandlerRebuild.spec.ts +++ b/src/core/webview/__tests__/ClineProvider.apiHandlerRebuild.spec.ts @@ -239,6 +239,8 @@ describe("ClineProvider - API Handler Rebuild Guard", () => { new ContextProxy(mockContext), new WebviewFocusTracker(), ) + // Start without the snapshot from initial fixture storage; profile tests seed their own mapping. + provider["initialModeConfigIds"] = Promise.resolve({}) // Mock providerSettingsManager ;(provider as any).providerSettingsManager = { @@ -967,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 fa042f5b86..abced7bd61 100644 --- a/src/core/webview/__tests__/ClineProvider.lockApiConfig.spec.ts +++ b/src/core/webview/__tests__/ClineProvider.lockApiConfig.spec.ts @@ -331,6 +331,8 @@ describe("ClineProvider - Lock API Config Across Modes", () => { new ContextProxy(mockContext), new WebviewFocusTracker(), ) + // Start without the snapshot from initial fixture storage; profile tests seed their own mapping. + provider["initialModeConfigIds"] = Promise.resolve({}) // Mock getMcpHub method provider.getMcpHub = vi.fn().mockReturnValue({ @@ -372,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 @@ -392,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 464889418e..52f79de031 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" @@ -559,6 +562,8 @@ describe("ClineProvider", () => { new ContextProxy(mockContext), new WebviewFocusTracker(), ) + // Start without the snapshot from initial fixture storage; profile tests seed their own mapping. + provider["initialModeConfigIds"] = Promise.resolve({}) defaultTaskOptions = { provider, @@ -4611,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]), @@ -4623,12 +4629,243 @@ 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") }) - it("saves current config when switching to mode without config", async () => { + 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) + + 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") + await expect(provider["getModeConfigId"]("code")).resolves.toBe("this-window-id") + // An unmapped mode keeps this provider's current profile. + await expect(provider["getModeConfigId"]("architect")).resolves.toBeUndefined() + }) + + 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("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"]]) + + 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 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") + }) + + 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") + 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") + } + }, + ) + }) + + 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") + + await expect(provider["getModeConfigId"]("architect")).resolves.toBe("opened-with-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 () => { + 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("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.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) + 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("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] @@ -4647,8 +4884,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 () => { @@ -5214,6 +5451,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]), @@ -5229,7 +5467,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") @@ -5237,7 +5475,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 @@ -5262,8 +5500,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" })) @@ -5338,6 +5576,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 @@ -5484,6 +5723,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 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), ), ) }