From ff7c9a868d2997bac05f8a41ec74a75b7db0e87e Mon Sep 17 00:00:00 2001 From: easonLiangWorldedtech <136036952+easonLiangWorldedtech@users.noreply.github.com> Date: Thu, 29 Oct 2026 03:00:17 +0800 Subject: [PATCH 01/42] feat(webview): durable per-view viewStates pipeline (N2) Split unit N2 of #1546: viewStates read/write queue, claim rekey, prune, clear, load/save and export/import sanitization on top of N1 identity. Buffer/mutation/history content remains for N3. --- .husky/pre-commit | 26 - .husky/pre-push | 42 -- .../src/__tests__/global-settings.test.ts | 43 ++ packages/types/src/__tests__/index.test.ts | 5 + packages/types/src/global-settings.ts | 17 + packages/types/src/vscode-extension-host.ts | 15 + src/core/config/ContextProxy.ts | 3 + src/core/config/ProviderSettingsManager.ts | 20 +- .../config/__tests__/ContextProxy.spec.ts | 16 + .../__tests__/ProviderSettingsManager.spec.ts | 7 +- .../config/__tests__/importExport.spec.ts | 45 ++ src/core/config/importExport.ts | 8 + src/core/webview/ClineProvider.ts | 649 +++++++++++++++++- .../webview/__tests__/ClineProvider.spec.ts | 50 +- 14 files changed, 860 insertions(+), 86 deletions(-) delete mode 100644 .husky/pre-commit delete mode 100644 .husky/pre-push diff --git a/.husky/pre-commit b/.husky/pre-commit deleted file mode 100644 index f8f420dac7..0000000000 --- a/.husky/pre-commit +++ /dev/null @@ -1,26 +0,0 @@ -branch="$(git rev-parse --abbrev-ref HEAD)" - -if [ "$branch" = "main" ]; then - echo "You can't commit directly to main - please check out a branch." - exit 1 -fi - -# Detect if running on Windows and use pnpm.cmd, otherwise use pnpm. -if [ "$OS" = "Windows_NT" ]; then - pnpm_cmd="pnpm.cmd" -else - if command -v pnpm >/dev/null 2>&1; then - pnpm_cmd="pnpm" - else - pnpm_cmd="npx pnpm" - fi -fi - -# Detect if running on Windows and use npx.cmd, otherwise use npx. -if [ "$OS" = "Windows_NT" ]; then - npx_cmd="npx.cmd" -else - npx_cmd="npx" -fi - -$npx_cmd lint-staged diff --git a/.husky/pre-push b/.husky/pre-push deleted file mode 100644 index 4cf91d9580..0000000000 --- a/.husky/pre-push +++ /dev/null @@ -1,42 +0,0 @@ -branch="$(git rev-parse --abbrev-ref HEAD)" - -if [ "$branch" = "main" ]; then - echo "You can't push directly to main - please check out a branch." - exit 1 -fi - -# Detect if running on Windows and use pnpm.cmd, otherwise use pnpm. -if [ "$OS" = "Windows_NT" ]; then - pnpm_cmd="pnpm.cmd" -else - if command -v pnpm >/dev/null 2>&1; then - pnpm_cmd="pnpm" - else - pnpm_cmd="npx pnpm" - fi -fi - -$pnpm_cmd run check-types - -# Use dotenvx to securely load .env.local and run commands that depend on it -if [ -f ".env.local" ]; then - # Check if RUN_TESTS_ON_PUSH is set to true and run tests with dotenvx - if npx dotenvx get RUN_TESTS_ON_PUSH -f .env.local 2>/dev/null | grep -q "^true$"; then - npx dotenvx run -f .env.local -- $pnpm_cmd run test - fi -else - # Fallback: run tests if RUN_TESTS_ON_PUSH is set in regular environment - if [ "$RUN_TESTS_ON_PUSH" = "true" ]; then - $pnpm_cmd run test - fi -fi - -# Check for new changesets. -NEW_CHANGESETS=$(find .changeset -name "*.md" ! -name "README.md" | wc -l | tr -d ' ') -echo "Changeset files: $NEW_CHANGESETS" - -if [ "$NEW_CHANGESETS" = "0" ]; then - echo "-------------------------------------------------------------------------------------" - echo "Changes detected. Please run 'pnpm changeset' to create a changeset if applicable." - echo "-------------------------------------------------------------------------------------" -fi diff --git a/packages/types/src/__tests__/global-settings.test.ts b/packages/types/src/__tests__/global-settings.test.ts index f2b2e7e8e5..b6b01cccf0 100644 --- a/packages/types/src/__tests__/global-settings.test.ts +++ b/packages/types/src/__tests__/global-settings.test.ts @@ -39,6 +39,49 @@ describe("alwaysDenyUnapprovedCommands global setting", () => { }) }) +describe("viewStates global setting", () => { + it("parses a valid per-view record", () => { + const parsed = globalSettingsSchema.parse({ + viewStates: { + "stable-view-1": { mode: "code", currentApiConfigName: "profile-a", updatedAt: 1730000000000 }, + "stable-view-2": {}, + }, + }) + expect(parsed.viewStates?.["stable-view-1"]).toEqual({ + mode: "code", + currentApiConfigName: "profile-a", + updatedAt: 1730000000000, + }) + expect(parsed.viewStates?.["stable-view-2"]).toEqual({}) + expect(GLOBAL_SETTINGS_KEYS).toContain("viewStates") + }) + + it("parses an entry that carries the host-minted claim token", () => { + // The claim binds the entry to the webview that wrote it; a legacy entry without one + // still parses, because refusing it is setViewStateId's job, not the schema's. + const parsed = globalSettingsSchema.parse({ + viewStates: { + "stable-view-1": { mode: "code", updatedAt: 1730000000000, claimToken: "7f9c-host-minted" }, + "stable-view-2": { mode: "code" }, + }, + }) + expect(parsed.viewStates?.["stable-view-1"]?.claimToken).toBe("7f9c-host-minted") + expect(parsed.viewStates?.["stable-view-2"]).toEqual({ mode: "code" }) + }) + + it("rejects invalid field values inside a view entry", () => { + expect(() => globalSettingsSchema.parse({ viewStates: { v: { mode: 42 } } })).toThrow() + expect(() => globalSettingsSchema.parse({ viewStates: { v: { currentApiConfigName: 42 } } })).toThrow() + expect(() => globalSettingsSchema.parse({ viewStates: { v: { updatedAt: "soon" } } })).toThrow() + expect(() => globalSettingsSchema.parse({ viewStates: { v: { claimToken: 42 } } })).toThrow() + }) + + it("rejects non-object viewStates values", () => { + expect(() => globalSettingsSchema.parse({ viewStates: "not-a-record" })).toThrow() + expect(() => globalSettingsSchema.parse({ viewStates: { v: "not-an-entry" } })).toThrow() + }) +}) + describe("collapseCommandOutputByDefault global setting", () => { it.each([true, false, undefined])("round-trips %s through the export/import schema", (value) => { const settings = globalSettingsSchema.parse({ collapseCommandOutputByDefault: value }) diff --git a/packages/types/src/__tests__/index.test.ts b/packages/types/src/__tests__/index.test.ts index 15441d48fd..b4cee22f8c 100644 --- a/packages/types/src/__tests__/index.test.ts +++ b/packages/types/src/__tests__/index.test.ts @@ -3,6 +3,10 @@ import { GLOBAL_STATE_KEYS } from "../index.js" describe("GLOBAL_STATE_KEYS", () => { + it("should contain registered durable per-view state", () => { + expect(GLOBAL_STATE_KEYS).toContain("viewStates") + }) + it("should contain provider settings keys", () => { expect(GLOBAL_STATE_KEYS).toContain("autoApprovalEnabled") }) @@ -13,6 +17,7 @@ describe("GLOBAL_STATE_KEYS", () => { it("should not contain secret state keys", () => { expect(GLOBAL_STATE_KEYS).not.toContain("openRouterApiKey") + expect(GLOBAL_STATE_KEYS).not.toContain("apiKey") }) it("should contain OpenAI Compatible base URL setting", () => { diff --git a/packages/types/src/global-settings.ts b/packages/types/src/global-settings.ts index 2bd5573039..63b1ef8998 100644 --- a/packages/types/src/global-settings.ts +++ b/packages/types/src/global-settings.ts @@ -117,6 +117,22 @@ export const MAX_CHECKPOINT_TIMEOUT_SECONDS = 60 */ export const DEFAULT_CHECKPOINT_TIMEOUT_SECONDS = 15 +/** + * Persisted non-secret selections for a stable webview instance. + */ +export const viewStateSchema = z.object({ + mode: z.string().optional(), + currentApiConfigName: z.string().optional(), + updatedAt: z.number().optional(), + /** + * Host-minted capability token binding this entry to the webview that wrote it. + * Minted by the extension host (`crypto.randomUUID()`), delivered to that webview and + * never accepted from webview input. An entry is only re-adopted for a webview that + * presents this token, so a view cannot read another (e.g. closed) view's selections. + */ + claimToken: z.string().optional(), +}) + /** * GlobalSettings */ @@ -125,6 +141,7 @@ export const globalSettingsSchema = z.object({ currentApiConfigName: z.string().optional(), listApiConfigMeta: z.array(providerSettingsEntrySchema).optional(), pinnedApiConfigs: z.record(z.string(), z.boolean()).optional(), + viewStates: z.record(z.string(), viewStateSchema).optional(), lastShownAnnouncementId: z.string().optional(), customInstructions: z.string().optional(), diff --git a/packages/types/src/vscode-extension-host.ts b/packages/types/src/vscode-extension-host.ts index 02fc7b0463..648a851824 100644 --- a/packages/types/src/vscode-extension-host.ts +++ b/packages/types/src/vscode-extension-host.ts @@ -113,6 +113,7 @@ export interface ExtensionMessage { | "rooHistoryImportProgress" | "themeFixtureProbeRequest" | "diagnosticsRequest" + | "viewStateClaim" text?: string /** For fileContent: { path, content, error? } */ fileContent?: { path: string; content: string | null; error?: string } @@ -171,6 +172,13 @@ export interface ExtensionMessage { // eslint-disable-next-line @typescript-eslint/no-explicit-any values?: Record requestId?: string + /** + * For `viewStateClaim`: the durable `viewStates` key the delivered claim governs. The + * message is only ever sent to the webview that key belongs to. + */ + viewStateId?: string + /** For `viewStateClaim`: the host-minted token the webview stores and echoes on launch. */ + viewStateClaim?: string themeFixture?: WebviewThemeFixture diagnostics?: WebviewDiagnosticsSnapshot promptText?: string @@ -714,6 +722,13 @@ export interface WebviewMessage { | "themeFixtureProbeResponse" | "diagnosticsResponse" text?: string + viewStateId?: string + /** + * For `webviewDidLaunch`: the host-minted claim previously delivered for `viewStateId`. + * The webview only echoes what it was given; the host rejects an id whose stored claim + * does not match, so a view cannot adopt another view's persisted selections. + */ + viewStateClaim?: string taskId?: string editedMessageContent?: string tab?: "settings" | "history" | "mcp" | "modes" | "chat" | "marketplace" | "cloud" diff --git a/src/core/config/ContextProxy.ts b/src/core/config/ContextProxy.ts index e53f60fb83..26a253057e 100644 --- a/src/core/config/ContextProxy.ts +++ b/src/core/config/ContextProxy.ts @@ -67,6 +67,9 @@ const globalSettingsExportSchema = globalSettingsSchema.omit({ taskHistory: true, listApiConfigMeta: true, currentApiConfigName: true, + // Per-view selection state is machine-local: it keeps flowing through the + // normal runtime and pruning paths but must not transfer between settings. + viewStates: true, }) export class ContextProxy { diff --git a/src/core/config/ProviderSettingsManager.ts b/src/core/config/ProviderSettingsManager.ts index 79a9d67c79..c9a9e7ae5b 100644 --- a/src/core/config/ProviderSettingsManager.ts +++ b/src/core/config/ProviderSettingsManager.ts @@ -55,6 +55,19 @@ export const providerProfilesSchema = z.object({ export type ProviderProfiles = z.infer +/** + * Signals that a profile's configuration no longer exists. Callers that treat an + * already-deleted profile as an idempotent no-op branch on this type instead of + * matching error message text, which a profile name containing the phrase could + * otherwise spoof. + */ +export class ProviderSettingsNotFoundError extends Error { + constructor(message: string) { + super(message) + this.name = "ProviderSettingsNotFoundError" + } +} + export class ProviderSettingsManager { private static readonly SCOPE_PREFIX = "roo_cline_config_" private readonly defaultConfigId = this.generateId() @@ -514,7 +527,7 @@ export class ProviderSettingsManager { const providerProfiles = await this.load() if (!providerProfiles.apiConfigs[name]) { - throw new Error(`Config '${name}' not found`) + throw new ProviderSettingsNotFoundError(`Config '${name}' not found`) } if (Object.keys(providerProfiles.apiConfigs).length === 1) { @@ -525,6 +538,11 @@ export class ProviderSettingsManager { await this.store(providerProfiles) }) } catch (error) { + // A missing config is a caller-meaningful signal, not a failure: rethrow it + // unwrapped so callers can branch on the type instead of message text. + if (error instanceof ProviderSettingsNotFoundError) { + throw error + } throw new Error(`Failed to delete config: ${error}`) } } diff --git a/src/core/config/__tests__/ContextProxy.spec.ts b/src/core/config/__tests__/ContextProxy.spec.ts index 5d78e16351..33e4a9038b 100644 --- a/src/core/config/__tests__/ContextProxy.spec.ts +++ b/src/core/config/__tests__/ContextProxy.spec.ts @@ -1170,4 +1170,20 @@ Output only the summary of the conversation so far, without any additional comme expect(customSupportPromptsUpdateCalls.length).toBe(0) }) }) + + describe("export", () => { + it("should exclude viewStates from the exported settings", async () => { + await proxy.setValue("viewStates", { + "stable-sidebar-view": { mode: "architect", currentApiConfigName: "profile-a", updatedAt: 1 }, + }) + await proxy.setValue("customInstructions", "global instructions") + + const exported = await proxy.export() + + // Per-view selection state is machine-local and must never transfer + // between settings, while ordinary global settings keep round-tripping. + expect(exported).not.toHaveProperty("viewStates") + expect(exported?.customInstructions).toBe("global instructions") + }) + }) }) diff --git a/src/core/config/__tests__/ProviderSettingsManager.spec.ts b/src/core/config/__tests__/ProviderSettingsManager.spec.ts index c77464f9f2..2f894bd471 100644 --- a/src/core/config/__tests__/ProviderSettingsManager.spec.ts +++ b/src/core/config/__tests__/ProviderSettingsManager.spec.ts @@ -12,7 +12,7 @@ import { import { clearAllMocks } from "../../../test-utils/reset" import { makeExtensionContext } from "../../../test-utils/vscode" -import { ProviderSettingsManager, ProviderProfiles } from "../ProviderSettingsManager" +import { ProviderSettingsManager, ProviderSettingsNotFoundError, ProviderProfiles } from "../ProviderSettingsManager" // `export()` builds an API handler per profile to read model capabilities. Mock // buildApiHandler with the real @roo-code/types model definitions so the token-field @@ -973,6 +973,11 @@ describe("ProviderSettingsManager", () => { }), ) + // The typed not-found signal is the contract callers branch on: a profile + // name containing "not found" must not be matchable via message text. + await expect(providerSettingsManager.deleteConfig("nonexistent")).rejects.toBeInstanceOf( + ProviderSettingsNotFoundError, + ) await expect(providerSettingsManager.deleteConfig("nonexistent")).rejects.toThrow( "Config 'nonexistent' not found", ) diff --git a/src/core/config/__tests__/importExport.spec.ts b/src/core/config/__tests__/importExport.spec.ts index 6c66655325..b8c5cb3327 100644 --- a/src/core/config/__tests__/importExport.spec.ts +++ b/src/core/config/__tests__/importExport.spec.ts @@ -331,6 +331,51 @@ describe("importExport", () => { ]) }) + it("should not apply imported viewStates to the context proxy", async () => { + const fileContent = JSON.stringify({ + providerProfiles: { + currentApiConfigName: "test", + apiConfigs: { + test: { apiProvider: providerIdentifiers.openai, apiKey: "test-key", id: "test-id" }, + }, + }, + globalSettings: { + mode: "code", + viewStates: { + "stable-sidebar-view": { + mode: "architect", + currentApiConfigName: "profile-a", + updatedAt: 1, + }, + }, + }, + }) + + ;(fs.readFile as Mock).mockResolvedValue(fileContent) + + mockProviderSettingsManager.export.mockResolvedValue({ + currentApiConfigName: "default", + apiConfigs: { default: { apiProvider: providerIdentifiers.anthropic, id: "default-id" } }, + }) + + mockProviderSettingsManager.listConfig.mockResolvedValue([ + { name: "test", id: "test-id", apiProvider: providerIdentifiers.openai }, + { name: "default", id: "default-id", apiProvider: providerIdentifiers.anthropic }, + ]) + + const result = await importSettingsFromPath("/mock/path/settings.json", { + providerSettingsManager: mockProviderSettingsManager, + contextProxy: mockContextProxy, + customModesManager: mockCustomModesManager, + }) + + expect(result.success).toBe(true) + // Per-view selection state is machine-local: importing settings must not + // apply another machine's view pins, while other settings round-trip. + expect(mockContextProxy.setValues).toHaveBeenCalledWith({ mode: "code" }) + expect(result).not.toHaveProperty("globalSettings.viewStates") + }) + it("should return success: false when file content is invalid", async () => { ;(vscode.window.showOpenDialog as Mock).mockResolvedValue([{ fsPath: "/mock/path/settings.json" }]) diff --git a/src/core/config/importExport.ts b/src/core/config/importExport.ts index 9882039ad3..29c9497552 100644 --- a/src/core/config/importExport.ts +++ b/src/core/config/importExport.ts @@ -98,6 +98,14 @@ function sanitizeGlobalSettings(rawGlobalSettings: unknown): { for (const [key, rawValue] of Object.entries(rawGlobalSettings)) { const path = `globalSettings.${key}` + + // Per-view selection state is machine-local: it round-trips through the + // normal runtime and pruning paths, but importing it would pin selections + // from another machine's views on this one. + if (key === "viewStates") { + continue + } + const schema = globalSettingsShape[key as keyof GlobalSettings] if (!schema) { diff --git a/src/core/webview/ClineProvider.ts b/src/core/webview/ClineProvider.ts index 678b93a136..0c034ace61 100644 --- a/src/core/webview/ClineProvider.ts +++ b/src/core/webview/ClineProvider.ts @@ -75,6 +75,7 @@ import { isRetiredProvider, modelIdKeys, providerIdentifiers, + PROVIDER_SETTINGS_KEYS, } from "@roo-code/types" import { RateLimitClock, createRateLimitClock } from "../task/RateLimitClock" import { TaskRegistry } from "../task/TaskRegistry" @@ -133,7 +134,7 @@ import { forceFullModelDetailsLoad, hasLoadedFullDetails } from "../../api/provi import { ContextProxy } from "../config/ContextProxy" import { withoutInvalidDisplaySettings } from "../config/displaySettings" -import { ProviderSettingsManager } from "../config/ProviderSettingsManager" +import { ProviderSettingsManager, ProviderSettingsNotFoundError } from "../config/ProviderSettingsManager" import { CustomModesManager } from "../config/CustomModesManager" import { PendingActionSettlementError, Task } from "../task/Task" @@ -162,6 +163,14 @@ import { REQUESTY_BASE_URL } from "../../shared/utils/requesty" import { validateAndFixToolResultIds } from "../task/validateToolResultIds" import { PendingEditOperationStore, type PendingEditOperationInput } from "./PendingEditOperationStore" +type PersistedViewState = NonNullable[string] + +/** + * Values that can be held in a view-local state buffer (in-memory) and, for the + * non-secret subset, persisted durably per stable view id. + */ +type ViewLocalStateValues = Partial & Partial + /** * https://github.com/microsoft/vscode-webview-ui-toolkit-samples/blob/main/default/weather-webview/src/providers/WeatherViewProvider.ts * https://github.com/KumarVariable/vscode-extension-sidebar-html/blob/master/src/customSidebarViewProvider.ts @@ -250,6 +259,10 @@ export class ClineProvider public static readonly sideBarId = `${Package.name}.SidebarProvider` public static readonly tabPanelId = `${Package.name}.TabPanelProvider` private static activeInstances: Set = new Set() + private static nextViewId = 0 + private static readonly MAX_PERSISTED_VIEW_STATES = 50 + private static readonly MAX_VIEW_STATE_ID_LENGTH = 64 + private static persistedViewStateWriteQueue: Promise = Promise.resolve() private webviewDisposables: vscode.Disposable[] = [] private pendingThemeFixtureProbes = new Map< string, @@ -418,6 +431,45 @@ export class ClineProvider */ private clineMessagesSeq = 0 + /** + * Unique identifier for this provider instance's view. + * Based on renderContext and a monotonically increasing counter to ensure uniqueness across multiple instances. + */ + public readonly viewId: string + + /** + * Stable identifier for persisted per-view state keys. + * Defaults to viewId until the webview reports its VS Code-persisted id. + * A durable entry under this id is bound to the webview that wrote it by a host-minted + * claim token (see setViewStateId), so the entry - and the profile its pin brings back + * into the state post - can outlive this instance without becoming adoptable by any + * other webview. + */ + private viewStateId: string + + /** + * Whether this instance wrote an entry under its own session-local temporary id. + * Temporary ids restart from 0 on every extension host start, so an entry under the + * same name can belong to a different session. Only re-key entries this instance wrote. + */ + private wroteUnderTemporaryViewStateId = false + + /** + * Local state buffer for this specific view instance. + * Used to isolate mode, apiConfiguration, and other fields from the shared ContextProxy singleton + * when running in parallel (multi-tab) mode. + */ + private viewLocalState: Partial = {} + + /** + * This view's pinned profile name from the view-local buffer. Exposed for + * sibling-instance inspection (getAllInstances() filtering): `viewLocalState` + * is private and must not be reached through bracket access. + */ + get pinnedProfileName(): string | undefined { + return this.viewLocalState.currentApiConfigName + } + public isViewLaunched = false public settingsImportedAt?: number public readonly latestAnnouncementId = "nov-2026-v3.96.0-settings-costs-reliability" // v3.96.0 chat settings, provider costs, and reliability @@ -447,6 +499,11 @@ export class ClineProvider mdmService?: MdmService, ) { super() + // Initialize viewId based on renderContext and monotonically increasing instance identifier for uniqueness. + // activeInstances is used for visibility/iteration checks, so we keep tracking instances separately. + this.viewId = `${renderContext}-${ClineProvider.nextViewId++}` + this.viewStateId = this.viewId + ClineProvider.activeInstances.add(this) this.currentWorkspacePath = getWorkspacePath() this.pendingEditOperations = new PendingEditOperationStore( ClineProvider.PENDING_OPERATION_TIMEOUT_MS, @@ -513,6 +570,9 @@ export class ClineProvider await this.postStateToWebviewWithoutClineMessages() }) + // Load initial state from global state into viewLocalState buffer after dependencies used by getState are ready. + void this.loadViewState() + // Initialize MCP Hub through the singleton manager McpServerManager.getInstance(this.context, this) .then((hub) => { @@ -658,6 +718,462 @@ export class ClineProvider } } + /** + * Reads the registered viewStates map, returning a defensive copy. + * When fresh is set, the map is read directly from globalState (bypassing the + * ContextProxy cache) so serialized writes never observe a stale in-memory value. + */ + private getPersistedViewStates(options: { fresh?: boolean } = {}): Record { + const viewStates = options.fresh + ? this.context.globalState.get("viewStates") + : this.contextProxy.getValue("viewStates") + + if (!viewStates || typeof viewStates !== "object" || Array.isArray(viewStates)) { + return Object.create(null) + } + + // Copy onto a null prototype. A view id that names an Object.prototype key + // ("constructor", "toString", "valueOf", ...) must not resolve through the + // prototype chain and be mistaken for a persisted entry. + return Object.assign(Object.create(null), viewStates) + } + + /** + * Persists this view's non-secret selections through the serialized write queue. + * The write re-reads the map fresh and merges into the existing entry, removing the + * entry entirely when nothing persistable remains, so concurrent views cannot clobber it. + * The entry is keyed by the view id active when the change was made. Writes captured + * while the provider still holds its temporary (pre-launch) id persist under that id + * and are re-keyed to the stable view id when the webview registers one, so a change + * that lands before the launch message stays durable instead of being lost. + */ + private async savePersistedViewState(values: Partial): Promise { + // Capture the id at change time: a write belongs to the view that was active + // when the change was made, even if a newer id is registered while it is queued. + const viewStateId = this.viewStateId + // Set by the queued write when it had to mint a claim, delivered after it lands. + let mintedClaimToken: string | undefined + const write = ClineProvider.persistedViewStateWriteQueue.then(async () => { + const states = this.getPersistedViewStates({ fresh: true }) + // The first write to an unowned temporary id claims the slot instead of merging + // into it: temporary names restart from 0 on every host start, so an entry under + // this name can be a leftover from an earlier session, and merging would adopt its + // fields and later re-key them under the stable id. Entries under a stable id, or + // under the temporary id this instance already authored, keep the merge semantics. + const ownsTargetEntry = viewStateId !== this.viewId || this.wroteUnderTemporaryViewStateId + const current = ownsTargetEntry ? (states[viewStateId] ?? {}) : {} + const next: PersistedViewState = { ...current } + + if ("mode" in values) { + if (values.mode === undefined || values.mode === null) { + delete next.mode + } else { + next.mode = values.mode + } + } + + if ("currentApiConfigName" in values) { + if (values.currentApiConfigName === undefined || values.currentApiConfigName === null) { + delete next.currentApiConfigName + } else { + next.currentApiConfigName = values.currentApiConfigName + } + } + + let wroteEntry = false + if (!next.mode && !next.currentApiConfigName) { + delete states[viewStateId] + } else { + next.updatedAt = values.updatedAt ?? Date.now() + // Bind the entry to this webview. An existing entry keeps the token it was + // adopted with (so a reload can still prove ownership); a new entry - or one + // written before claims existed - gets a fresh host-minted token. The token is + // never taken from `values`: it is host-owned, and webview input must not be + // able to choose or supply one. + if (!next.claimToken) { + next.claimToken = crypto.randomUUID() + mintedClaimToken = next.claimToken + } + states[viewStateId] = next + wroteEntry = true + } + + await this.contextProxy.setValue("viewStates", this.prunePersistedViewStates(states)) + // Authorship is recorded only after the durable write lands: a failed persistence + // must not mark the temporary id as owned, or a later load would adopt an entry + // that was never actually stored. + if (wroteEntry && viewStateId === this.viewId) { + this.wroteUnderTemporaryViewStateId = true + } + }) + + ClineProvider.persistedViewStateWriteQueue = write.catch(() => {}) + await write + + // Delivered only once the durable write landed: a webview must never hold a claim the + // host did not store, or the next launch would present a token the entry cannot match. + if (mintedClaimToken) { + this.postViewStateClaimToWebview(viewStateId, mintedClaimToken) + } + } + + /** + * Removes the given view's entry from the registered viewStates map. + * Runs through the serialized write queue to avoid racing concurrent view-state writes. + */ + private async clearPersistedViewState(viewStateId = this.viewStateId): Promise { + const write = ClineProvider.persistedViewStateWriteQueue.then(async () => { + const states = this.getPersistedViewStates({ fresh: true }) + delete states[viewStateId] + await this.contextProxy.setValue("viewStates", states) + }) + + ClineProvider.persistedViewStateWriteQueue = write.catch(() => {}) + await write + } + + /** + * Re-binds a claim-less viewStates entry to this webview with a freshly minted claim. + * Entries written before claims existed cannot be attributed to any webview, so their + * selections are dropped instead of being carried over: keeping them would let the new + * token re-expose them on a later launch, which is exactly the disclosure this binding + * exists to prevent. Runs through the serialized write queue like every other mutation. + */ + private async rebindUnboundViewStateEntry(viewStateId: string): Promise { + const claimToken = crypto.randomUUID() + let rebound = false + + const write = ClineProvider.persistedViewStateWriteQueue.then(async () => { + const states = this.getPersistedViewStates({ fresh: true }) + const current = states[viewStateId] + // A concurrent registration may have bound this key while this write was queued: + // never overwrite an existing claim, and let the caller refuse the stale adoption. + if (current && typeof current.claimToken === "string" && current.claimToken) { + return + } + states[viewStateId] = { claimToken, updatedAt: Date.now() } + await this.contextProxy.setValue("viewStates", this.prunePersistedViewStates(states)) + rebound = true + }) + + ClineProvider.persistedViewStateWriteQueue = write.catch(() => {}) + await write + + return rebound ? claimToken : undefined + } + + /** + * Delivers the host-minted claim that governs a durable viewStates key to this view's + * webview. The webview only stores it and echoes it back on the next launch: it can + * never mint or choose a claim itself. + */ + private postViewStateClaimToWebview(viewStateId: string, claimToken: string): void { + void this.postMessageToWebview({ type: "viewStateClaim", viewStateId, viewStateClaim: claimToken }) + } + + /** + * Keeps only the most recently updated entries of the persisted view states map, + * bounded by MAX_PERSISTED_VIEW_STATES so the global key cannot grow unboundedly. + */ + private prunePersistedViewStates(states: Record): Record { + return Object.fromEntries( + Object.entries(states) + .sort(([, a], [, b]) => (b.updatedAt ?? 0) - (a.updatedAt ?? 0)) + .slice(0, ClineProvider.MAX_PERSISTED_VIEW_STATES), + ) + } + + /** + * Re-keys this provider's temporary pre-launch viewStates entry to the newly + * registered stable id so pre-launch writes become durable under the stable key + * instead of orphaning under a session-local temporary id. Only the provider's own + * temporary id is eligible: an entry under a previously registered stable id belongs + * to that webview's storage and is left alone. When the stable entry already exists + * it wins and the temporary entry is dropped, because temporary ids are session + * counters that can collide across window reloads. Runs through the serialized write + * queue like every other viewStates mutation. An entry this instance never wrote is + * left alone, so a stale entry that happens to carry the same session-local name is + * not adopted. + */ + private async rekeyPersistedViewStateEntry(nextViewStateId: string): Promise { + const previousViewStateId = this.viewId + + const write = ClineProvider.persistedViewStateWriteQueue.then(async () => { + // An entry under this name can belong to a different session, because temporary + // ids restart from 0 on every extension host start. Only re-key entries this + // instance wrote, otherwise a stale entry from another session is adopted. + if (!this.wroteUnderTemporaryViewStateId) { + return + } + + const states = this.getPersistedViewStates({ fresh: true }) + const previous = states[previousViewStateId] + + if (!previous) { + return + } + + delete states[previousViewStateId] + + if (!states[nextViewStateId]) { + states[nextViewStateId] = previous + } + + await this.contextProxy.setValue("viewStates", this.prunePersistedViewStates(states)) + + // Only a successful write clears authorship: a failed attempt leaves the entry + // under the temporary name, and a retry must still be able to re-key it. + this.wroteUnderTemporaryViewStateId = false + }) + + ClineProvider.persistedViewStateWriteQueue = write.catch(() => {}) + await write + } + + /** + * Registers this provider's stable view identifier and loads any persisted selections it owns. + * The identifier is sanitized so it remains a safe object key in the shared viewStates map. + * + * `presentedClaim` is the host-minted token this webview was given for that id. It is the + * only proof of ownership: an entry that carries a claim is loaded only when the presented + * token matches it, so a webview cannot adopt another (e.g. disposed, still durable) view's + * id and read that view's pinned profile - and the profile secrets copied into the state + * post - back out of it. The check runs before any re-keying or loading. + */ + public async setViewStateId(viewStateId: string | undefined, presentedClaim?: string): Promise { + // The webview generates this id on purpose - it has to survive a webview reload, + // which recreates the view on both sides - so the host cannot mint it instead. + // What the host owns is which view may hold a given persisted key, so everything + // below validates the supplied value before it becomes one. + if (typeof viewStateId !== "string") { + // A crafted postMessage can carry any JSON value here even though the message + // type declares a string; the persisted key must stay a string. + this.log(`[setViewStateId] Ignoring a non-string viewStateId for view ${this.viewId}.`) + return + } + + const normalizedViewStateId = viewStateId.trim().replace(/[^A-Za-z0-9_-]/g, "_") + + if ( + !normalizedViewStateId || + normalizedViewStateId === this.viewStateId || + // Reject "__proto__" and any other prototype-chain key. The map is copied + // onto a null prototype, so these names can no longer resolve through the + // chain, but they are still rejected as ids so a caller cannot store an + // entry under a name that looks like an inherited member. + normalizedViewStateId === "__proto__" + ) { + return + } + + // Bound the key: the webview generates a UUID, so a much longer value is not a + // view id, and an unbounded key is unbounded growth in the shared viewStates map. + if (normalizedViewStateId.length > ClineProvider.MAX_VIEW_STATE_ID_LENGTH) { + this.log( + `[setViewStateId] Ignoring an oversized viewStateId (${normalizedViewStateId.length} chars) for view ${this.viewId}.`, + ) + return + } + + const claimant = ClineProvider.getAllInstances().find( + (instance) => instance !== this && instance.viewStateId === normalizedViewStateId, + ) + if (claimant) { + // Ownership check: a key another live view holds must not be adopted. Doing so + // would load that view's pinned profile, nested overlay, and mode into this + // provider, and this webview could then overwrite that view's persisted entry. + // Staying on the temporary id keeps this view working against the shared state. + this.log( + `[setViewStateId] Refusing viewStateId ${normalizedViewStateId} for view ${this.viewId}: already claimed by live view ${claimant.viewId}.`, + ) + return + } + + // Claim binding, checked before any re-key or load so a refused registration can + // neither read nor mutate a persisted entry. Read fresh from storage rather than + // through the ContextProxy cache: a security check must not trust a stale copy. + const persistedEntry = this.getPersistedViewStates({ fresh: true })[normalizedViewStateId] + + if (persistedEntry) { + const storedClaim = persistedEntry.claimToken + + if (typeof storedClaim !== "string" || !storedClaim) { + // A pre-claim entry cannot be attributed to any webview, so its selections are + // never loaded. Re-establish the binding with a fresh host-minted claim and hand + // that claim to this webview: the key becomes adoptable again (no upgrade brick) + // and the unbound selections are gone, so the new token cannot resurrect them. + const reboundClaim = await this.rebindUnboundViewStateEntry(normalizedViewStateId) + + if (reboundClaim === undefined) { + // A concurrent registration bound the key while the re-bind was queued: this + // launch adopts a key another webview now owns, so refuse it instead of + // handing out a claim that is not ours. + this.log( + `[setViewStateId] Refusing viewStateId ${normalizedViewStateId} for view ${this.viewId}: bound concurrently by another registration.`, + ) + return + } + + this.postViewStateClaimToWebview(normalizedViewStateId, reboundClaim) + this.log( + `[setViewStateId] Re-bound claim-less viewStates entry ${normalizedViewStateId} for view ${this.viewId}: unbound selections were not loaded.`, + ) + } else if (typeof presentedClaim !== "string" || presentedClaim !== storedClaim) { + // Fail closed: the entry belongs to a webview that never presented this view's + // claim. Rejection is side-effect free, so presenting an id cannot probe, mutate + // or delete another view's entry. + this.log( + `[setViewStateId] Refusing viewStateId ${normalizedViewStateId} for view ${this.viewId}: claim missing or mismatched.`, + ) + return + } + } + + const previousViewStateId = this.viewStateId + + this.viewStateId = normalizedViewStateId + + try { + // Re-key any durable entry written under the temporary pre-launch id before + // loading, so the load sees the view's own pre-registration selections. + await this.rekeyPersistedViewStateEntry(this.viewStateId) + + await this.loadViewState() + + // Re-affirm the binding for the id just adopted: a claim minted while this view was + // still on its temporary id now governs this key (the entry was re-keyed), so the + // webview is told the canonical (viewStateId, claim) pair to echo on its next launch. + const adoptedClaim = this.getPersistedViewStates({ fresh: true })[this.viewStateId]?.claimToken + + if (adoptedClaim) { + this.postViewStateClaimToWebview(this.viewStateId, adoptedClaim) + } + } catch (error) { + // A persistence failure must not leave the provider holding an id that was + // never registered: restore the previous id so a later launch retries the + // registration and the load instead of the guard above early-returning for + // the failed id. + this.viewStateId = previousViewStateId + throw error + } + } + + /** + * Loads non-secret persisted selections from the registered viewStates map. + * Missing entries are intentionally left unset so getState() falls back to shared ContextProxy values. + * Fields mutated while the async profile lookup is in flight are reapplied on top of the + * loaded state, field by field, so in-flight user selections are not clobbered by the load. + */ + private async loadViewState(): Promise { + // Capture the id this load is for: a newer id registered while an async + // profile lookup is in flight must not be overwritten by this stale load. + const loadedForViewId = this.viewStateId + + // While the stable id has not been registered yet, the key is this instance's + // session-local name. Temporary names restart from 0 on every host start, so an + // entry under the same name can belong to a different session. Load only entries + // this instance authored. + if (loadedForViewId === this.viewId && !this.wroteUnderTemporaryViewStateId) { + return + } + try { + const persisted = this.getPersistedViewStates()[loadedForViewId] + const loadedState: Partial = {} + + // Snapshot the in-memory buffer before the async profile lookup. The + // mutation paths update viewLocalState in place, so a shallow copy is + // what makes fields mutated during the load window observable below. + const preLoadBuffer = { ...this.viewLocalState } + + if (persisted?.mode) { + // A persisted mode may reference a custom mode that was deleted after it was + // pinned: restore it only when the slug still resolves, so a stale slug cannot + // shadow the shared mode from getState(). + const customModes = await this.customModesManager.getCustomModes() + if (getModeBySlug(persisted.mode, customModes)) { + loadedState.mode = persisted.mode as Mode + } else { + this.log(`[loadViewState] Ignoring unknown persisted mode "${persisted.mode}"`) + } + } + + if (persisted?.currentApiConfigName) { + loadedState.currentApiConfigName = persisted.currentApiConfigName + + try { + const { name: _name, ...apiConfiguration } = await this.providerSettingsManager.getProfile({ + name: persisted.currentApiConfigName, + }) + loadedState.apiConfiguration = apiConfiguration as ProviderSettings + } catch (error) { + this.log( + `[loadViewState] Unable to resolve API profile '${persisted.currentApiConfigName}' for viewId ${this.viewId}: ${error instanceof Error ? error.message : String(error)}`, + ) + } + } + + if (this.viewStateId !== loadedForViewId) { + this.log(`[loadViewState] Discarding stale state for superseded view id ${loadedForViewId}`) + return + } + + // Reapply the buffer fields that changed while the load was in flight, + // tracking the change instead of testing against undefined: a field cleared + // during the load window must stay cleared (the loaded value must not + // resurrect it), and a field written to a new value must win over it. + // Untouched fields keep the persisted values authoritative, and the + // pre-load buffer is never merged wholesale so stale temporary-id state + // cannot override the stable persisted state. + const postLoadBuffer = this.viewLocalState + const mergedState: Partial = { ...loadedState } + + if (!Object.is(preLoadBuffer.mode, postLoadBuffer.mode)) { + if (postLoadBuffer.mode === undefined) { + delete mergedState.mode + } else { + mergedState.mode = postLoadBuffer.mode + } + } + + if (!Object.is(preLoadBuffer.currentApiConfigName, postLoadBuffer.currentApiConfigName)) { + if (postLoadBuffer.currentApiConfigName === undefined) { + delete mergedState.currentApiConfigName + } else { + mergedState.currentApiConfigName = postLoadBuffer.currentApiConfigName + } + } + + if (!Object.is(preLoadBuffer.apiConfiguration, postLoadBuffer.apiConfiguration)) { + if (postLoadBuffer.apiConfiguration === undefined) { + delete mergedState.apiConfiguration + } else { + mergedState.apiConfiguration = postLoadBuffer.apiConfiguration + } + } + + this.viewLocalState = mergedState + this.log(`[loadViewState] Loaded state for viewId ${this.viewId}`) + } catch (error) { + this.log( + `[loadViewState] Error loading state for viewId ${this.viewId}: ${error instanceof Error ? error.message : String(error)}`, + ) + } + } + + /** + * Saves a single view-local state value. The in-memory buffer is always updated; the + * non-secret subset (mode, currentApiConfigName) is persisted durably under the view + * id active when the change was made, re-keyed to the stable id on registration. + */ + public async saveViewState( + key: K, + value: ViewLocalStateValues[K] | undefined, + ): Promise { + await this._saveViewLocalStateFromMutation({ [key]: value } as ViewLocalStateValues) + + this.log(`[saveViewState] Saved ${String(key)} for viewId ${this.viewId}`) + } + /** * Override EventEmitter's on method to match TaskProviderLike interface */ @@ -1003,7 +1519,6 @@ export class ClineProvider ) } } - async dispose() { if (this._disposed) { return @@ -1512,7 +2027,6 @@ export class ClineProvider ) return run } - private async createTaskWithHistoryItemUnlocked( historyItem: HistoryItem & { rootTask?: Task; parentTask?: Task }, options?: { startTask?: boolean }, @@ -1758,7 +2272,6 @@ export class ClineProvider return task } - public async postMessageToWebview(message: ExtensionMessage) { const startedAt = Date.now() const taskId = this.getCurrentTask()?.taskId @@ -2108,7 +2621,6 @@ export class ClineProvider this.handleModeSwitchUnlocked(newMode, targetTask, signal), ) } - private async handleModeSwitchUnlocked( newMode: Mode, targetTask: Task | null | undefined, @@ -2438,9 +2950,17 @@ export class ClineProvider // `allSettled` so a caller that rolls back after a failure never races a write still in flight. const activationResults = await Promise.allSettled([ this.updateGlobalState("listApiConfigMeta", await this.providerSettingsManager.listConfig()), - this.updateGlobalState("currentApiConfigName", name), + // Route through setValue so the in-memory viewLocalState buffer tracks the + // activated profile: a plain global write would leave a stale loaded + // currentApiConfigName shadowing the new value in getValues(). + this.setValue("currentApiConfigName", name), this.setModeConfig(mode, id), this.contextProxy.setProviderSettings(providerSettings), + // setProviderSettings writes the shared store directly, bypassing the + // view-local mutation path: also refresh this view's buffer so a stale + // loaded apiConfiguration cannot keep shadowing the new settings in + // getState(). + this._saveViewLocalStateFromMutation({ apiConfiguration: providerSettings }), ]) const failedActivation = activationResults.find( (result): result is PromiseRejectedResult => result.status === "rejected", @@ -2450,6 +2970,10 @@ export class ClineProvider if (signal.aborted) return id + // Other live views may have buffered this profile's settings earlier; + // refresh them so their getState() cannot report the updated profile's + // name with stale settings. + // Change the provider for the current task. // TODO: We should rename `buildApiHandler` for clarity (e.g. `getProviderClient`). this.updateTaskApiHandlerIfNeeded(providerSettings, { forceRebuild: true }) @@ -2458,6 +2982,21 @@ export class ClineProvider await this.persistStickyProviderProfileToCurrentTask(name) } else { await this.updateGlobalState("listApiConfigMeta", await this.providerSettingsManager.listConfig()) + + // A save that does not activate still changes the profile's settings, and + // every view pinned to it buffers a full copy of them. Refresh those views + // (and this one when it is the pinned view) or their getState() keeps + // serving the settings captured before the save under the same name. + if (this.pinnedProfileName === name) { + await this._saveViewLocalStateFromMutation({ apiConfiguration: providerSettings }) + // Only rebuild when the task actually runs under the saved profile: a + // view pinned to this profile can hold a task that follows a different + // sticky profile, and the forced rebuild would silently switch that + // conversation to the saved profile's settings. + if (this.getCurrentTask()?.taskApiConfigName === name) { + this.updateTaskApiHandlerIfNeeded(providerSettings, { forceRebuild: true }) + } + } } if (signal.aborted) return id @@ -2465,7 +3004,6 @@ export class ClineProvider await this.postStateToWebview() return id } - async deleteProviderProfile(profileToDelete: ProviderSettingsEntry) { const globalSettings = this.contextProxy.getValues() let profileToActivate: string | undefined = globalSettings.currentApiConfigName @@ -2533,7 +3071,6 @@ export class ClineProvider this.activateProviderProfileUnlocked(args, options, signal), ) } - private async activateProviderProfileUnlocked( args: { name: string } | { id: string }, options?: { @@ -2665,9 +3202,6 @@ export class ClineProvider await this.upsertProviderProfile(currentApiConfigName, newConfiguration) } - - // Zoo Code Auth - async handleZooCodeCallback(token: string) { // Auth mutation (token storage, subscription check, success toast) was already // performed by handleAuthCallback() in handleUri.ts before this method was called. @@ -3806,7 +4340,6 @@ export class ClineProvider private getGlobalState(key: K) { return this.contextProxy.getValue(key) } - public async setValue(key: K, value: RooCodeSettings[K]) { await this.contextProxy.setValue(key, value) } @@ -3814,19 +4347,55 @@ export class ClineProvider public getValue(key: K) { return this.contextProxy.getValue(key) } - public getValues() { return this.contextProxy.getValues() } - public async setValues(values: RooCodeSettings) { await this.contextProxy.setValues( withoutInvalidDisplaySettings(values, (key) => this.log(`[setValues] Ignored an invalid value for ${key}`)), ) } - // dev + /** + * Persists the view-local subset of a ContextProxy mutation, then updates the in-memory + * viewLocalState buffer. Persistence is awaited first so a failed durable write cannot + * leave the local cache ahead of the persisted state. + */ + private async _saveViewLocalStateFromMutation( + values: Partial & Partial, + ): Promise { + await this._persistViewLocalStateFromMutation(values) + this._updateViewLocalStateFromMutation(values) + } + + /** + * Writes the durably persisted subset of a mutation (mode and currentApiConfigName) + * into the registered viewStates map for this view. + */ + private async _persistViewLocalStateFromMutation( + values: Partial & Partial, + ): Promise { + const persistedValues: Partial = {} + if ("mode" in values) { + persistedValues.mode = values.mode as PersistedViewState["mode"] + } + + if ("currentApiConfigName" in values) { + persistedValues.currentApiConfigName = values.currentApiConfigName + } + + if ("mode" in persistedValues || "currentApiConfigName" in persistedValues) { + await this.savePersistedViewState(persistedValues) + } + } + + /** + * Clear view-local state cache so that getState() falls back to ContextProxy defaults. + */ + private _clearViewLocalState(): void { + this.viewLocalState = {} + } async resetState() { const answer = await vscode.window.showInformationMessage( t("common:confirmation.reset_state"), @@ -5591,4 +6160,54 @@ export class ClineProvider return vscode.Uri.file(filePath).toString() } } + + /** + * Update or invalidate viewLocalState when ContextProxy is mutated via setValues, setValue, + * profile upsert/activation/deletion, or resetState. This ensures the local cache stays in + * sync with global state changes that would otherwise be invisible behind mergedStateValues. + */ + private _updateViewLocalStateFromMutation(values: Partial & Partial): void { + if ("mode" in values) { + const val = values.mode + if (val === undefined || val === null) { + delete this.viewLocalState.mode + } else { + this.viewLocalState.mode = val + } + } + + if ("currentApiConfigName" in values) { + const val = values.currentApiConfigName + if (val === undefined || val === null) { + delete this.viewLocalState.currentApiConfigName + } else { + this.viewLocalState.currentApiConfigName = val + } + } + + if ("apiConfiguration" in values) { + const val = values.apiConfiguration + if (val === undefined || val === null) { + delete this.viewLocalState.apiConfiguration + } else { + this.viewLocalState.apiConfiguration = val + } + } else if (PROVIDER_SETTINGS_KEYS.some((key) => key in values)) { + const providerSettingsUpdate = PROVIDER_SETTINGS_KEYS.reduce((acc, key) => { + if (key in values) { + return { ...acc, [key]: values[key as keyof RooCodeSettings] } + } + + return acc + }, {} as ProviderSettings) + + this.viewLocalState.apiConfiguration = + "apiProvider" in providerSettingsUpdate + ? providerSettingsUpdate + : { + ...(this.viewLocalState.apiConfiguration ?? {}), + ...providerSettingsUpdate, + } + } + } } diff --git a/src/core/webview/__tests__/ClineProvider.spec.ts b/src/core/webview/__tests__/ClineProvider.spec.ts index c5925ab4d2..3625733fe7 100644 --- a/src/core/webview/__tests__/ClineProvider.spec.ts +++ b/src/core/webview/__tests__/ClineProvider.spec.ts @@ -31,14 +31,16 @@ 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 { ProviderSettingsManager, ProviderSettingsNotFoundError } 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" +import { t } from "../../../i18n" import { ClineProvider } from "../ClineProvider" import { webviewMessageHandler } from "../webviewMessageHandler" +import type { MdmService } from "../../../services/mdm/MdmService" import { Terminal } from "../../../integrations/terminal/Terminal" import { MessageManager } from "../../message-manager" import { forceFullModelDetailsLoad, hasLoadedFullDetails } from "../../../api/providers/fetchers/lmstudio" @@ -428,6 +430,52 @@ afterAll(() => { vi.restoreAllMocks() }) +/** + * Minimal profile shape the stalled getProfile double resolves to. The + * settings fields are optional so a lookup that resolves name-only (a + * profile with no configured provider) also type-checks. + */ +type StalledProfile = { + name: string + apiProvider?: string + openRouterModelId?: string +} + +/** + * Swap the provider's ProviderSettingsManager for a double whose getProfile + * stalls until the test resolves it, so tests can mutate view state while + * loadViewState is in flight. The double only backs getProfile, the member + * loadViewState awaits; the documented @ts-ignore replaces the per-test + * suppressions the inlined copies used. + */ +function stallProviderSettingsProfile(provider: ClineProvider) { + let resolveProfile: (value: StalledProfile) => void = () => {} + const getProfileSpy = vi.fn(() => { + // Only one lookup is resolvable: resolveProfile is bound to the first + // promise's resolver, so a second getProfile would strand its promise. + // Fail loudly instead of hanging. + if (getProfileSpy.mock.calls.length > 1) { + throw new Error( + "stallProviderSettingsProfile: getProfile called more than once; only one lookup is resolvable", + ) + } + return new Promise((resolve) => (resolveProfile = resolve)) + }) + // @ts-ignore - Reassign the readonly providerSettingsManager for the test; the double only backs getProfile. + provider.providerSettingsManager = { getProfile: getProfileSpy } + // Return a stable wrapper around the closure binding: resolveProfile is + // reassigned to the pending promise's resolver once getProfile is called, + // so returning the variable directly would hand the test the initial no-op. + return { getProfile: getProfileSpy, resolveProfile: (value: StalledProfile) => resolveProfile(value) } +} + +/** + * The host-minted claim stored with a durable view-states entry. A test that adopts an + * entry another provider wrote has to present it, exactly like a webview does on launch. + */ +function persistedViewStateClaim(context: vscode.ExtensionContext, viewStateId: string): string | undefined { + return context.globalState.get("viewStates")?.[viewStateId]?.claimToken +} describe("ClineProvider", () => { beforeAll(() => { vi.mocked(Task).mockImplementation(function (options: any) { From ab6026ed9c5f816ed46bdfe0014190e88c7cd91a Mon Sep 17 00:00:00 2001 From: easonLiangWorldedtech <136036952+easonLiangWorldedtech@users.noreply.github.com> Date: Thu, 29 Oct 2026 20:58:44 +0800 Subject: [PATCH 02/42] test(webview): carry the identity and durable viewStates tests with N2 N2 spec now includes the N1 identity tests plus the persistence/load/prune/rekey/export-import coverage; the setValues buffer test moves to the buffer unit. --- .../webview/__tests__/ClineProvider.spec.ts | 832 +++++++++++++++++- 1 file changed, 810 insertions(+), 22 deletions(-) diff --git a/src/core/webview/__tests__/ClineProvider.spec.ts b/src/core/webview/__tests__/ClineProvider.spec.ts index 3625733fe7..98d62ca56c 100644 --- a/src/core/webview/__tests__/ClineProvider.spec.ts +++ b/src/core/webview/__tests__/ClineProvider.spec.ts @@ -1,4 +1,4 @@ -// pnpm --filter roo-cline test core/webview/__tests__/ClineProvider.spec.ts +// pnpm --filter roo-cline test core/webview/__tests__/ClineProvider.spec.ts import fs from "fs" import fsPromises from "fs/promises" @@ -36,11 +36,9 @@ 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" -import { t } from "../../../i18n" import { ClineProvider } from "../ClineProvider" import { webviewMessageHandler } from "../webviewMessageHandler" -import type { MdmService } from "../../../services/mdm/MdmService" import { Terminal } from "../../../integrations/terminal/Terminal" import { MessageManager } from "../../message-manager" import { forceFullModelDetailsLoad, hasLoadedFullDetails } from "../../../api/providers/fetchers/lmstudio" @@ -430,24 +428,12 @@ afterAll(() => { vi.restoreAllMocks() }) -/** - * Minimal profile shape the stalled getProfile double resolves to. The - * settings fields are optional so a lookup that resolves name-only (a - * profile with no configured provider) also type-checks. - */ type StalledProfile = { name: string apiProvider?: string openRouterModelId?: string } -/** - * Swap the provider's ProviderSettingsManager for a double whose getProfile - * stalls until the test resolves it, so tests can mutate view state while - * loadViewState is in flight. The double only backs getProfile, the member - * loadViewState awaits; the documented @ts-ignore replaces the per-test - * suppressions the inlined copies used. - */ function stallProviderSettingsProfile(provider: ClineProvider) { let resolveProfile: (value: StalledProfile) => void = () => {} const getProfileSpy = vi.fn(() => { @@ -469,13 +455,6 @@ function stallProviderSettingsProfile(provider: ClineProvider) { return { getProfile: getProfileSpy, resolveProfile: (value: StalledProfile) => resolveProfile(value) } } -/** - * The host-minted claim stored with a durable view-states entry. A test that adopts an - * entry another provider wrote has to present it, exactly like a webview does on launch. - */ -function persistedViewStateClaim(context: vscode.ExtensionContext, viewStateId: string): string | undefined { - return context.globalState.get("viewStates")?.[viewStateId]?.claimToken -} describe("ClineProvider", () => { beforeAll(() => { vi.mocked(Task).mockImplementation(function (options: any) { @@ -6071,6 +6050,815 @@ describe("ClineProvider", () => { ]) }) }) + + describe("setViewStateId", () => { + it('should ignore "__proto__" and keep the temporary viewId', async () => { + const provider = new ClineProvider( + mockContext, + mockOutputChannel, + "sidebar", + new ContextProxy(mockContext), + new WebviewFocusTracker(), + ) + + await provider["setViewStateId"]("__proto__") + + // "__proto__" is rejected before assignment so a per-view entry can never be + // keyed through the Object.prototype setter: the temporary id stays active and + // nothing is persisted under the reserved name. + expect(provider["viewStateId"]).toBe(provider.viewId) + expect(mockContext.globalState.get("viewStates")).toBeUndefined() + expect(provider["viewLocalState"]).toEqual({}) + + await provider.dispose() + }) + + it("restores the previous view id when the registration write fails so a later launch retries", async () => { + const contextProxy = new ContextProxy(mockContext) + const provider = new ClineProvider( + mockContext, + mockOutputChannel, + "sidebar", + contextProxy, + new WebviewFocusTracker(), + ) + // Seed a pre-launch entry under the temporary id through the real write path, + // so the re-key has real work to do and records this instance as its author. + await provider["savePersistedViewState"]({ mode: "architect", updatedAt: 1 }) + + const setValueSpy = vi.spyOn(contextProxy, "setValue").mockRejectedValue(new Error("storage down")) + + await expect(provider["setViewStateId"]("stable-sidebar-view")).rejects.toThrow("storage down") + + // The failed id must not stick: the provider keeps its previous (temporary) + // id so a later launch retries registration and the load instead of the + // guard early-returning for an id that was never persisted. + expect(provider["viewStateId"]).toBe(provider.viewId) + + // A later retry succeeds once the storage write works again, and the + // pre-launch entry lands under the registered id. + setValueSpy.mockRestore() + await provider["setViewStateId"]("stable-sidebar-view") + expect(provider["viewStateId"]).toBe("stable-sidebar-view") + expect(mockContext.globalState.get("viewStates")).toEqual({ + "stable-sidebar-view": { mode: "architect", updatedAt: 1, claimToken: expect.any(String) }, + }) + + await provider.dispose() + }) + }) + + describe("view state claim binding", () => { + it("refuses a viewStateId bound by a concurrent registration through setViewStateId", async () => { + const provider = new ClineProvider( + mockContext, + mockOutputChannel, + "sidebar", + new ContextProxy(mockContext), + new WebviewFocusTracker(), + ) + const beforeViewStateId = provider["viewStateId"] + const postSpy = vi.spyOn(provider, "postMessageToWebview").mockResolvedValue(undefined) + // A claim-less entry is adoptable at the first read, but a concurrent registration + // binds the key while this launch's queued re-bind is waiting its turn. + await provider.contextProxy.setValue("viewStates", { "legacy-view": { updatedAt: 1 } }) + ClineProvider["persistedViewStateWriteQueue"] = Promise.resolve().then(async () => { + await provider.contextProxy.setValue("viewStates", { + "legacy-view": { claimToken: "winner", updatedAt: 2 }, + }) + }) + + await provider["setViewStateId"]("legacy-view") + + // The launch must not adopt a key another webview now owns: no claim is delivered, + // the provider stays on its temporary id, and the winner's claim is untouched. + expect(postSpy).not.toHaveBeenCalledWith(expect.objectContaining({ type: "viewStateClaim" })) + expect(provider["viewStateId"]).toBe(beforeViewStateId) + const states = provider.contextProxy.getValue("viewStates") as Record + expect(states["legacy-view"].claimToken).toBe("winner") + ClineProvider["persistedViewStateWriteQueue"] = Promise.resolve() + postSpy.mockRestore() + await provider.dispose() + }) + + it("does not overwrite a claim bound by a concurrent registration", async () => { + const provider = new ClineProvider( + mockContext, + mockOutputChannel, + "sidebar", + new ContextProxy(mockContext), + new WebviewFocusTracker(), + ) + await provider.contextProxy.setValue("viewStates", { "legacy-view": { updatedAt: 1 } }) + // A concurrent registration binds this key while the re-bind write is queued. + ClineProvider["persistedViewStateWriteQueue"] = Promise.resolve().then(async () => { + await provider.contextProxy.setValue("viewStates", { + "legacy-view": { claimToken: "winner", updatedAt: 2 }, + }) + }) + + const claim = await provider["rebindUnboundViewStateEntry"]("legacy-view") + + // The queued re-bind must not replace the claim the other registration wrote; it + // reports that nothing was rebound so the caller can refuse the stale adoption. + expect(claim).toBeUndefined() + const states = provider.contextProxy.getValue("viewStates") as Record + expect(states["legacy-view"].claimToken).toBe("winner") + ClineProvider["persistedViewStateWriteQueue"] = Promise.resolve() + await provider.dispose() + }) + + const createProvider = () => + new ClineProvider( + mockContext, + mockOutputChannel, + "sidebar", + new ContextProxy(mockContext), + new WebviewFocusTracker(), + ) + + const storedEntries = () => + mockContext.globalState.get>("viewStates") ?? {} + + test("refuses a disposed view's id when no claim is presented, and loads nothing", async () => { + // The vulnerable path: a view registers a durable entry, is disposed, and a second + // webview presents the same id. dispose() removes the instance but leaves the entry, + // so only the claim can stop the second webview from loading the first one's pinned + // profile (and the profile's secrets) through the state post. + const owner = createProvider() + await owner["setViewStateId"]("closed-view") + await owner.saveViewState("mode", "architect") + await owner.saveViewState("currentApiConfigName", "profile-with-secrets") + + const storedClaim = storedEntries()["closed-view"]?.claimToken + expect(storedClaim).toEqual(expect.any(String)) + + await owner.dispose() + + const intruder = createProvider() + const postMessageSpy = vi.spyOn(intruder, "postMessageToWebview").mockResolvedValue(undefined) + + await intruder["setViewStateId"]("closed-view") + + // Fail closed: the id is not adopted, no selections reach this view and no state is + // posted back to the webview that asked for it. + expect(intruder["viewStateId"]).toBe(intruder.viewId) + expect(intruder["viewLocalState"]).toStrictEqual({}) + expect((await intruder.getState()).currentApiConfigName).not.toBe("profile-with-secrets") + expect(postMessageSpy).not.toHaveBeenCalled() + + // A refused adoption is side-effect free: presenting an id must not probe or rewrite + // the entry that a different webview owns. + expect(storedEntries()["closed-view"]).toMatchObject({ + mode: "architect", + currentApiConfigName: "profile-with-secrets", + claimToken: storedClaim, + }) + + await intruder.dispose() + }) + + test("refuses a mismatched claim", async () => { + const owner = createProvider() + await owner["setViewStateId"]("closed-view") + await owner.saveViewState("currentApiConfigName", "profile-with-secrets") + await owner.dispose() + + const intruder = createProvider() + const postMessageSpy = vi.spyOn(intruder, "postMessageToWebview").mockResolvedValue(undefined) + + // A webview-generated value is not a claim: only the token the host minted matches. + await intruder["setViewStateId"]("closed-view", "webview-chosen-claim") + + expect(intruder["viewStateId"]).toBe(intruder.viewId) + expect(intruder["viewLocalState"]).toStrictEqual({}) + expect(postMessageSpy).not.toHaveBeenCalled() + + await intruder.dispose() + }) + + test("does not churn the claim on later writes to the same entry", async () => { + const postMessageSpy = vi.spyOn(provider, "postMessageToWebview").mockResolvedValue(undefined) + await provider["setViewStateId"]("minted-view") + await provider.saveViewState("mode", "architect") + + const mintedClaim = storedEntries()["minted-view"]?.claimToken + expect(mintedClaim).toEqual(expect.any(String)) + + await provider.saveViewState("currentApiConfigName", "profile-b") + + // A merge into an entry this view already owns keeps its token, so the claim the + // webview holds keeps working and is not re-sent. + expect(storedEntries()["minted-view"]?.claimToken).toBe(mintedClaim) + expect( + postMessageSpy.mock.calls.map(([message]) => message).filter((m) => m.type === "viewStateClaim"), + ).toHaveLength(1) + }) + + test("re-binds a claim-less legacy entry instead of loading its selections", async () => { + // An entry written before claims existed cannot be attributed to any webview: its + // selections are refused, and the key is re-bound with a fresh host-minted claim so + // the upgrade does not brick per-view persistence. + await provider.contextProxy.setValue("viewStates", { + "legacy-view": { mode: "architect", currentApiConfigName: "profile-a", updatedAt: 1 }, + }) + + const postMessageSpy = vi.spyOn(provider, "postMessageToWebview").mockResolvedValue(undefined) + + await provider["setViewStateId"]("legacy-view") + + // No stored selection is adopted... + expect(provider["viewStateId"]).toBe("legacy-view") + expect(provider["viewLocalState"]).toStrictEqual({}) + + // ...the old entry is replaced by a claim-bearing one with the unbound selections gone... + const rebound = storedEntries()["legacy-view"] + expect(rebound).toEqual({ claimToken: expect.any(String), updatedAt: expect.any(Number) }) + expect(rebound).not.toHaveProperty("mode") + expect(rebound).not.toHaveProperty("currentApiConfigName") + + // ...and the fresh claim is handed to this webview so the next launch can prove ownership. + expect(postMessageSpy).toHaveBeenCalledWith({ + type: "viewStateClaim", + viewStateId: "legacy-view", + viewStateClaim: rebound?.claimToken, + }) + + await provider.dispose() + + const reopened = createProvider() + await reopened["setViewStateId"]("legacy-view", rebound?.claimToken) + + expect(reopened["viewStateId"]).toBe("legacy-view") + expect(reopened["viewLocalState"]).toStrictEqual({}) + + await reopened.dispose() + }) + + test("still refuses an id a live view holds, even when the claim matches", async () => { + const owner = createProvider() + await owner["setViewStateId"]("shared-live-view") + await owner.saveViewState("mode", "architect") + const claim = storedEntries()["shared-live-view"]?.claimToken + + const sibling = createProvider() + + try { + await sibling["setViewStateId"]("shared-live-view", claim) + + // The live-instance guard runs first and keeps working: a second live view never + // shares a key with the view that holds it. + expect(sibling["viewStateId"]).toBe(sibling.viewId) + expect(sibling["viewLocalState"]).toStrictEqual({}) + expect(owner["viewStateId"]).toBe("shared-live-view") + } finally { + await sibling.dispose() + await owner.dispose() + } + }) + }) + + describe("view state persistence edge cases", () => { + it("should read viewStates from the ContextProxy cache when not fresh", async () => { + const provider = new ClineProvider( + mockContext, + mockOutputChannel, + "sidebar", + new ContextProxy(mockContext), + new WebviewFocusTracker(), + ) + await provider.contextProxy.setValue("viewStates", { "stable-sidebar-view": { mode: "architect" } }) + expect(provider["getPersistedViewStates"]()).toEqual({ "stable-sidebar-view": { mode: "architect" } }) + await provider.dispose() + }) + + it("should treat a corrupted non-object viewStates value as an empty map", async () => { + const provider = new ClineProvider( + mockContext, + mockOutputChannel, + "sidebar", + new ContextProxy(mockContext), + new WebviewFocusTracker(), + ) + // A string in storage is corrupt: the fresh-read guard must not spread it. + await mockContext.globalState.update("viewStates", "corrupted-storage-value") + expect(provider["getPersistedViewStates"]({ fresh: true })).toEqual({}) + await provider.dispose() + }) + + it("should merge saved fields, drop cleared fields and delete emptied entries", async () => { + const provider = new ClineProvider( + mockContext, + mockOutputChannel, + "sidebar", + new ContextProxy(mockContext), + new WebviewFocusTracker(), + ) + const logSpy = vi.spyOn(provider, "log") + const save = provider.saveViewState.bind(provider) as (key: string, value: unknown) => Promise + const states = () => mockContext.globalState.get>("viewStates") ?? {} + await provider["setViewStateId"]("stable-sidebar-view") + await provider.saveViewState("mode", "architect") + await provider.saveViewState("currentApiConfigName", "profile-a") + const merged = states()["stable-sidebar-view"] + expect(merged).toMatchObject({ mode: "architect", currentApiConfigName: "profile-a" }) + expect(logSpy).toHaveBeenCalledWith(expect.stringContaining("Saved mode for viewId")) + await save("mode", undefined) + expect(states()["stable-sidebar-view"]).toStrictEqual({ + currentApiConfigName: "profile-a", + updatedAt: expect.any(Number), + claimToken: expect.any(String), + }) + await save("mode", null) + expect(states()["stable-sidebar-view"]).not.toHaveProperty("mode") + await provider.saveViewState("mode", "architect") + await save("currentApiConfigName", undefined) + expect(states()["stable-sidebar-view"]).toStrictEqual({ + mode: "architect", + updatedAt: expect.any(Number), + claimToken: expect.any(String), + }) + await provider.saveViewState("currentApiConfigName", "profile-c") + await provider.saveViewState("mode", "architect") + expect(states()["stable-sidebar-view"]).toMatchObject({ + mode: "architect", + currentApiConfigName: "profile-c", + }) + await save("currentApiConfigName", null) + expect(states()["stable-sidebar-view"]).not.toHaveProperty("currentApiConfigName") + await save("mode", null) + expect(states()["stable-sidebar-view"]).toBeUndefined() + expect(provider["viewLocalState"]).toStrictEqual({}) // buffer ends fully cleared + await provider.dispose() + }) + + it("should rekey a pre-launch entry under the temporary id to the registered stable id", async () => { + const provider = new ClineProvider( + mockContext, + mockOutputChannel, + "sidebar", + new ContextProxy(mockContext), + new WebviewFocusTracker(), + ) + // Seed through the write path so this instance is the author of the entry under + // its temporary id; an entry authored by another session must not be adopted. + await provider["savePersistedViewState"]({ mode: "architect", updatedAt: 1 }) + await provider["setViewStateId"]("stable-sidebar-view") + expect(mockContext.globalState.get("viewStates")).toEqual({ + // The minted claim travels with the re-keyed entry, so the webview's token keeps working. + "stable-sidebar-view": { mode: "architect", updatedAt: 1, claimToken: expect.any(String) }, + }) + await provider.dispose() + }) + + it("should keep the stable entry and drop the temporary entry when both exist", async () => { + const provider = new ClineProvider( + mockContext, + mockOutputChannel, + "sidebar", + new ContextProxy(mockContext), + new WebviewFocusTracker(), + ) + // Author the temporary entry through the write path so this instance owns it, + // then add a stable entry that already exists in storage. + await provider["savePersistedViewState"]({ mode: "temp-mode", updatedAt: 1 }) + await provider.contextProxy.setValue("viewStates", { + [provider.viewId]: { mode: "temp-mode", updatedAt: 1 }, + "stable-sidebar-view": { mode: "stable-mode", updatedAt: 5, claimToken: "stable-claim" }, + }) + await provider["setViewStateId"]("stable-sidebar-view", "stable-claim") + expect(mockContext.globalState.get("viewStates")).toEqual({ + "stable-sidebar-view": { mode: "stable-mode", updatedAt: 5, claimToken: "stable-claim" }, + }) + await provider.dispose() + }) + + it("should prune by updatedAt regardless of insertion order", async () => { + const provider = new ClineProvider( + mockContext, + mockOutputChannel, + "sidebar", + new ContextProxy(mockContext), + new WebviewFocusTracker(), + ) + const states = Object.fromEntries( + Array.from({ length: 55 }, (_, index) => [ + `view-${index}`, + { mode: `mode-${index}`, updatedAt: (index * 7) % 55 }, + ]), + ) + const pruned = provider["prunePersistedViewStates"](states) + expect(Object.keys(pruned)).toHaveLength(50) + // view-1/view-54 survive the true newest-50 selection; view-8 (updatedAt 1) does not. + expect(pruned["view-1"]).toEqual({ mode: "mode-1", updatedAt: 7 }) + expect(pruned["view-54"]).toEqual({ mode: "mode-54", updatedAt: 48 }) + expect(pruned["view-8"]).toBeUndefined() + await provider.dispose() + }) + + it("should log a successful empty load when no persisted entry exists", async () => { + const provider = new ClineProvider( + mockContext, + mockOutputChannel, + "sidebar", + new ContextProxy(mockContext), + new WebviewFocusTracker(), + ) + const logSpy = vi.spyOn(provider, "log") + await provider["setViewStateId"]("stable-sidebar-view") + expect(provider["viewLocalState"]).toEqual({}) + expect(logSpy).toHaveBeenCalledWith(expect.stringContaining("Loaded state for viewId")) + await provider.dispose() + }) + + it("should keep the persisted profile name and log when the profile lookup fails", async () => { + const provider = new ClineProvider( + mockContext, + mockOutputChannel, + "sidebar", + new ContextProxy(mockContext), + new WebviewFocusTracker(), + ) + const logSpy = vi.spyOn(provider, "log") + // @ts-ignore - Replace providerSettingsManager with a failing test double. + provider.providerSettingsManager = { getProfile: vi.fn().mockRejectedValue(new Error("profile missing")) } + await provider.saveViewState("currentApiConfigName", "my-profile") + await provider["setViewStateId"]("stable-sidebar-view") + expect(provider["viewLocalState"].currentApiConfigName).toBe("my-profile") + expect(provider["viewLocalState"]).not.toHaveProperty("apiConfiguration") + expect(logSpy).toHaveBeenCalledWith(expect.stringContaining("Unable to resolve API profile 'my-profile'")) + await provider.dispose() + }) + + it("should discard a stale load when the viewStateId changes during the profile lookup", async () => { + const provider = new ClineProvider( + mockContext, + mockOutputChannel, + "sidebar", + new ContextProxy(mockContext), + new WebviewFocusTracker(), + ) + const logSpy = vi.spyOn(provider, "log") + // @ts-ignore - Replace providerSettingsManager with a test double that registers a newer id. + provider.providerSettingsManager = { + getProfile: vi.fn().mockImplementation(() => { + provider["viewStateId"] = "superseded-view" + return Promise.resolve({ name: "my-profile", apiProvider: providerIdentifiers.openrouter }) + }), + } + await provider.saveViewState("currentApiConfigName", "my-profile") + await provider["setViewStateId"]("stable-sidebar-view") + expect(provider["viewLocalState"]).not.toHaveProperty("apiConfiguration") + const staleMsg = expect.stringContaining("Discarding stale state for superseded view id") + expect(logSpy).toHaveBeenCalledWith(staleMsg) + await provider.dispose() + }) + + it("should not restore a persisted mode whose custom mode no longer exists", async () => { + const provider = new ClineProvider( + mockContext, + mockOutputChannel, + "sidebar", + new ContextProxy(mockContext), + new WebviewFocusTracker(), + ) + const logSpy = vi.spyOn(provider, "log") + // @ts-ignore - Replace customModesManager with a test double (no custom modes). + provider.customModesManager = { getCustomModes: vi.fn().mockResolvedValue([]), dispose: vi.fn() } + // The file-level modes mock resolves every slug to a mode; drop the pinned slug. + const modesModule = vi.mocked(await import("../../../shared/modes")) + const originalMode = modesModule.getModeBySlug("code") + modesModule.getModeBySlug.mockImplementation(((slug: string) => + slug === "deleted-custom-mode" ? undefined : originalMode) as typeof modesModule.getModeBySlug) + try { + await provider["setViewStateId"]("stable-sidebar-view") + await provider.saveViewState("mode", "deleted-custom-mode") + // Reload the persisted entry: the custom mode was deleted in the meantime. + await provider["loadViewState"]() + // The stale slug must not be restored into the buffer. + expect(provider["viewLocalState"]).not.toHaveProperty("mode") + expect(logSpy).toHaveBeenCalledWith( + expect.stringContaining('Ignoring unknown persisted mode "deleted-custom-mode"'), + ) + } finally { + modesModule.getModeBySlug.mockReturnValue(originalMode) + } + await provider.dispose() + }) + + it("should keep every persisted field authoritative when the load is untouched", async () => { + const provider = new ClineProvider( + mockContext, + mockOutputChannel, + "sidebar", + new ContextProxy(mockContext), + new WebviewFocusTracker(), + ) + const { getProfile: getProfileSpy, resolveProfile } = stallProviderSettingsProfile(provider) + // @ts-ignore - Replace customModesManager with a test double (no custom modes). + provider.customModesManager = { getCustomModes: vi.fn().mockResolvedValue([]), dispose: vi.fn() } + await provider.saveViewState("mode", "code") + await provider.saveViewState("currentApiConfigName", "cfg-a") + const load = provider["setViewStateId"]("stable-sidebar-view") + + // Let the stalled lookup begin so the in-flight mutation and the resolver + // target the pending promise rather than the initial no-op. + await vi.waitFor(() => expect(getProfileSpy).toHaveBeenCalledTimes(1)) + // No mutation while the lookup is in flight: the persisted values must win. + resolveProfile({ name: "cfg-a", apiProvider: providerIdentifiers.openrouter, openRouterModelId: "model-x" }) + await load + + expect(provider["viewLocalState"]).toEqual({ + mode: "code", + currentApiConfigName: "cfg-a", + apiConfiguration: { apiProvider: providerIdentifiers.openrouter, openRouterModelId: "model-x" }, + }) + await provider.dispose() + }) + }) + + describe("saveViewState", () => { + it("should update viewLocalState and persist mode through registered viewStates", async () => { + const provider = new ClineProvider( + mockContext, + mockOutputChannel, + "sidebar", + new ContextProxy(mockContext), + new WebviewFocusTracker(), + ) + + const contextProxySpy = vi.spyOn(provider.contextProxy, "setValue") + await provider["setViewStateId"]("stable-sidebar-view") + + await provider.saveViewState("mode", "architect") + + expect(provider["viewLocalState"].mode).toBe("architect") + expect(provider.contextProxy.getValue("viewStates")).toMatchObject({ + "stable-sidebar-view": { mode: "architect" }, + }) + expect(contextProxySpy).toHaveBeenCalledWith( + "viewStates", + expect.objectContaining({ + "stable-sidebar-view": expect.objectContaining({ + mode: "architect", + updatedAt: expect.any(Number), + }), + }), + ) + expect(contextProxySpy).not.toHaveBeenCalledWith("__view_state_stable-sidebar-view_mode", expect.anything()) + + await provider.dispose() + }) + + it("should update viewLocalState and persist currentApiConfigName through registered viewStates", async () => { + const provider = new ClineProvider( + mockContext, + mockOutputChannel, + "sidebar", + new ContextProxy(mockContext), + new WebviewFocusTracker(), + ) + + await provider["setViewStateId"]("stable-sidebar-view") + await provider.saveViewState("currentApiConfigName", "my-profile") + + expect(provider["viewLocalState"].currentApiConfigName).toBe("my-profile") + expect(provider.contextProxy.getValue("viewStates")).toMatchObject({ + "stable-sidebar-view": { currentApiConfigName: "my-profile" }, + }) + + await provider.dispose() + }) + + it("should update viewLocalState for apiConfiguration without persisting provider settings or secrets", async () => { + const provider = new ClineProvider( + mockContext, + mockOutputChannel, + "sidebar", + new ContextProxy(mockContext), + new WebviewFocusTracker(), + ) + + const testApiConfig = { + apiProvider: providerIdentifiers.openrouter, + openRouterModelId: "claude-3.5-sonnet", + openRouterApiKey: "secret-key", + } + + await provider["setViewStateId"]("stable-sidebar-view") + await provider.saveViewState("apiConfiguration", testApiConfig) + + expect(provider["viewLocalState"].apiConfiguration).toEqual(testApiConfig) + expect(provider.contextProxy.getValue("viewStates")).toBeUndefined() + + await provider.dispose() + }) + + it("should clear local override when saveViewState receives undefined", async () => { + const provider = new ClineProvider( + mockContext, + mockOutputChannel, + "sidebar", + new ContextProxy(mockContext), + new WebviewFocusTracker(), + ) + + await provider.saveViewState("mode", "architect") + expect(provider["viewLocalState"].mode).toBe("architect") + + await provider.saveViewState("mode", undefined) + + expect(Object.prototype.hasOwnProperty.call(provider["viewLocalState"], "mode")).toBe(false) + + await provider.dispose() + }) + + it("should clear the currentApiConfigName override when saveViewState receives undefined", async () => { + const provider = new ClineProvider( + mockContext, + mockOutputChannel, + "sidebar", + new ContextProxy(mockContext), + new WebviewFocusTracker(), + ) + + await provider.saveViewState("currentApiConfigName", "my-profile") + expect(provider["viewLocalState"].currentApiConfigName).toBe("my-profile") + + await provider.saveViewState("currentApiConfigName", undefined) + + expect(Object.prototype.hasOwnProperty.call(provider["viewLocalState"], "currentApiConfigName")).toBe(false) + + await provider.dispose() + }) + + it("should not update viewLocalState when durable view-state persistence fails", async () => { + const provider = new ClineProvider( + mockContext, + mockOutputChannel, + "sidebar", + new ContextProxy(mockContext), + new WebviewFocusTracker(), + ) + vi.spyOn(provider.contextProxy, "setValue").mockRejectedValueOnce(new Error("persist failed")) + + await provider["setViewStateId"]("stable-sidebar-view") + + await expect(provider.saveViewState("mode", "architect")).rejects.toThrow("persist failed") + expect(provider["viewLocalState"]).not.toHaveProperty("mode") + expect(provider.contextProxy.getValue("viewStates")).toBeUndefined() + + await provider.dispose() + }) + + it("should merge concurrent persisted updates from separate provider instances without lost viewStates", async () => { + const provider1 = new ClineProvider( + mockContext, + mockOutputChannel, + "sidebar", + new ContextProxy(mockContext), + + new WebviewFocusTracker(), + ) + const provider2 = new ClineProvider( + mockContext, + mockOutputChannel, + "editor", + new ContextProxy(mockContext), + new WebviewFocusTracker(), + ) + + await provider1["setViewStateId"]("stable-sidebar-view") + await provider2["setViewStateId"]("stable-editor-view") + + await Promise.all([ + provider1.saveViewState("mode", "architect"), + provider2.saveViewState("currentApiConfigName", "editor-profile"), + ]) + + expect(mockContext.globalState.get("viewStates")).toMatchObject({ + "stable-sidebar-view": { mode: "architect" }, + "stable-editor-view": { currentApiConfigName: "editor-profile" }, + }) + + await provider1.dispose() + await provider2.dispose() + }) + }) + + describe("loadViewState", () => { + it("should keep viewLocalState empty when no stable per-view values exist", async () => { + const provider = new ClineProvider( + mockContext, + mockOutputChannel, + "sidebar", + new ContextProxy(mockContext), + new WebviewFocusTracker(), + ) + + await vi.waitFor(() => { + expect(provider["viewLocalState"]).toEqual({}) + }) + + const state = await provider.getState() + // No per-view entry exists and the proxy's global-state cache is empty + // (initialize() is never called in this fixture; only "taskHistory" passes + // through to the context store), so getState() falls back to the shared + // defaults: mode "code" (defaultModeSlug) and currentApiConfigName "default". + expect(state.mode).toBe("code") + expect(state.currentApiConfigName).toBe("default") + + await provider.dispose() + }) + + it("should log and keep existing viewLocalState when loadViewState fails", async () => { + const provider = new ClineProvider( + mockContext, + mockOutputChannel, + "sidebar", + new ContextProxy(mockContext), + new WebviewFocusTracker(), + ) + const logSpy = vi.spyOn(provider, "log") + + // Register a stable id so the load is not skipped by the ownership guard: + // only entries this instance authored are loaded under a temporary name. + await provider["setViewStateId"]("stable-sidebar-view") + + provider["viewLocalState"] = { mode: "architect" } + vi.spyOn(provider.contextProxy, "getValue").mockImplementation(() => { + throw new Error("load failed") + }) + + await provider["loadViewState"]() + + expect(provider["viewLocalState"].mode).toBe("architect") + expect(logSpy).toHaveBeenCalledWith(expect.stringContaining("Error loading state")) + + await provider.dispose() + }) + }) + + describe("persisted view state pruning", () => { + it("should keep the newest 50 persisted view states", async () => { + const provider = new ClineProvider( + mockContext, + mockOutputChannel, + "sidebar", + new ContextProxy(mockContext), + new WebviewFocusTracker(), + ) + const states = Object.fromEntries( + Array.from({ length: 55 }, (_, index) => [ + `view-${index}`, + { mode: `mode-${index}`, updatedAt: index }, + ]), + ) + + const pruned = provider["prunePersistedViewStates"](states) + + expect(Object.keys(pruned)).toHaveLength(50) + expect(pruned["view-54"]).toEqual({ mode: "mode-54", updatedAt: 54 }) + expect(pruned["view-5"]).toEqual({ mode: "mode-5", updatedAt: 5 }) + expect(pruned["view-4"]).toBeUndefined() + + await provider.dispose() + }) + }) + + it("should merge concurrent persisted updates from separate provider instances without lost viewStates", async () => { + const provider1 = new ClineProvider( + mockContext, + mockOutputChannel, + "sidebar", + new ContextProxy(mockContext), + + new WebviewFocusTracker(), + ) + const provider2 = new ClineProvider( + mockContext, + mockOutputChannel, + "editor", + new ContextProxy(mockContext), + new WebviewFocusTracker(), + ) + + await provider1["setViewStateId"]("stable-sidebar-view") + await provider2["setViewStateId"]("stable-editor-view") + + await Promise.all([ + provider1.saveViewState("mode", "architect"), + provider2.saveViewState("currentApiConfigName", "editor-profile"), + ]) + + expect(mockContext.globalState.get("viewStates")).toMatchObject({ + "stable-sidebar-view": { mode: "architect" }, + "stable-editor-view": { currentApiConfigName: "editor-profile" }, + }) + + await provider1.dispose() + await provider2.dispose() + }) }) describe("webviewMessageHandler no-floating-promises coverage", () => { From a155faee7a05133473f53d56b876a322c11893c8 Mon Sep 17 00:00:00 2001 From: easonLiangWorldedtech <136036952+easonLiangWorldedtech@users.noreply.github.com> Date: Thu, 29 Oct 2026 20:59:19 +0800 Subject: [PATCH 03/42] chore: restore main tracked husky hooks --- .husky/pre-commit | 26 ++++++++++++++++++++++++++ .husky/pre-push | 42 ++++++++++++++++++++++++++++++++++++++++++ 2 files changed, 68 insertions(+) create mode 100644 .husky/pre-commit create mode 100644 .husky/pre-push diff --git a/.husky/pre-commit b/.husky/pre-commit new file mode 100644 index 0000000000..f8f420dac7 --- /dev/null +++ b/.husky/pre-commit @@ -0,0 +1,26 @@ +branch="$(git rev-parse --abbrev-ref HEAD)" + +if [ "$branch" = "main" ]; then + echo "You can't commit directly to main - please check out a branch." + exit 1 +fi + +# Detect if running on Windows and use pnpm.cmd, otherwise use pnpm. +if [ "$OS" = "Windows_NT" ]; then + pnpm_cmd="pnpm.cmd" +else + if command -v pnpm >/dev/null 2>&1; then + pnpm_cmd="pnpm" + else + pnpm_cmd="npx pnpm" + fi +fi + +# Detect if running on Windows and use npx.cmd, otherwise use npx. +if [ "$OS" = "Windows_NT" ]; then + npx_cmd="npx.cmd" +else + npx_cmd="npx" +fi + +$npx_cmd lint-staged diff --git a/.husky/pre-push b/.husky/pre-push new file mode 100644 index 0000000000..4cf91d9580 --- /dev/null +++ b/.husky/pre-push @@ -0,0 +1,42 @@ +branch="$(git rev-parse --abbrev-ref HEAD)" + +if [ "$branch" = "main" ]; then + echo "You can't push directly to main - please check out a branch." + exit 1 +fi + +# Detect if running on Windows and use pnpm.cmd, otherwise use pnpm. +if [ "$OS" = "Windows_NT" ]; then + pnpm_cmd="pnpm.cmd" +else + if command -v pnpm >/dev/null 2>&1; then + pnpm_cmd="pnpm" + else + pnpm_cmd="npx pnpm" + fi +fi + +$pnpm_cmd run check-types + +# Use dotenvx to securely load .env.local and run commands that depend on it +if [ -f ".env.local" ]; then + # Check if RUN_TESTS_ON_PUSH is set to true and run tests with dotenvx + if npx dotenvx get RUN_TESTS_ON_PUSH -f .env.local 2>/dev/null | grep -q "^true$"; then + npx dotenvx run -f .env.local -- $pnpm_cmd run test + fi +else + # Fallback: run tests if RUN_TESTS_ON_PUSH is set in regular environment + if [ "$RUN_TESTS_ON_PUSH" = "true" ]; then + $pnpm_cmd run test + fi +fi + +# Check for new changesets. +NEW_CHANGESETS=$(find .changeset -name "*.md" ! -name "README.md" | wc -l | tr -d ' ') +echo "Changeset files: $NEW_CHANGESETS" + +if [ "$NEW_CHANGESETS" = "0" ]; then + echo "-------------------------------------------------------------------------------------" + echo "Changes detected. Please run 'pnpm changeset' to create a changeset if applicable." + echo "-------------------------------------------------------------------------------------" +fi From d5ce5bd408b97c718218c570045f1bbcfb8205eb Mon Sep 17 00:00:00 2001 From: easonLiangWorldedtech <136036952+easonLiangWorldedtech@users.noreply.github.com> Date: Thu, 29 Oct 2026 21:01:54 +0800 Subject: [PATCH 04/42] feat(webview): view-local buffer reads and setValue persistence (N3) Split unit N3: setValue/getValues view-local buffer and failed-write rollback on top of N2; setValues/reset/ack/history remain for N4/N5. --- src/core/webview/ClineProvider.ts | 28 +++- .../webview/__tests__/ClineProvider.spec.ts | 122 ++++++++++++++++++ 2 files changed, 149 insertions(+), 1 deletion(-) diff --git a/src/core/webview/ClineProvider.ts b/src/core/webview/ClineProvider.ts index 0c034ace61..31dbdd77a4 100644 --- a/src/core/webview/ClineProvider.ts +++ b/src/core/webview/ClineProvider.ts @@ -4340,15 +4340,26 @@ export class ClineProvider private getGlobalState(key: K) { return this.contextProxy.getValue(key) } + public async setValue(key: K, value: RooCodeSettings[K]) { + const previousSharedValues = { [key]: this.contextProxy.getValue(key) } as RooCodeSettings await this.contextProxy.setValue(key, value) + try { + await this._saveViewLocalStateFromMutation({ [key]: value }) + } catch (error) { + // The per-view record did not land: restore the prior shared value so the two + // persistence layers cannot diverge, then surface the original failure. + await this._restoreSharedValuesAfterFailedViewWrite(previousSharedValues) + throw error + } } public getValue(key: K) { return this.contextProxy.getValue(key) } + public getValues() { - return this.contextProxy.getValues() + return { ...this.contextProxy.getValues(), ...this.viewLocalState } } public async setValues(values: RooCodeSettings) { await this.contextProxy.setValues( @@ -6210,4 +6221,19 @@ export class ClineProvider } } } + + /** + * Restore shared values captured before a setter wrote them, used when the paired + * per-view persistence failed so the shared store cannot move ahead of the per-view + * record. A failed rollback is logged; the original failure is what callers see. + */ + private async _restoreSharedValuesAfterFailedViewWrite(previous: RooCodeSettings): Promise { + try { + await this.contextProxy.setValues(previous) + } catch (rollbackError) { + this.log( + `[ClineProvider] Shared-state rollback after failed per-view write failed: ${rollbackError instanceof Error ? rollbackError.message : String(rollbackError)}`, + ) + } + } } diff --git a/src/core/webview/__tests__/ClineProvider.spec.ts b/src/core/webview/__tests__/ClineProvider.spec.ts index 98d62ca56c..83d8c0579c 100644 --- a/src/core/webview/__tests__/ClineProvider.spec.ts +++ b/src/core/webview/__tests__/ClineProvider.spec.ts @@ -455,6 +455,10 @@ function stallProviderSettingsProfile(provider: ClineProvider) { return { getProfile: getProfileSpy, resolveProfile: (value: StalledProfile) => resolveProfile(value) } } +function persistedViewStateClaim(context: vscode.ExtensionContext, viewStateId: string): string | undefined { + return context.globalState.get("viewStates")?.[viewStateId]?.claimToken +} + describe("ClineProvider", () => { beforeAll(() => { vi.mocked(Task).mockImplementation(function (options: any) { @@ -6859,6 +6863,124 @@ describe("ClineProvider", () => { await provider1.dispose() await provider2.dispose() }) + + describe("view state persistence edge cases", () => { + it("should load persisted mode, profile name and resolved profile into viewLocalState", async () => { + const writer = new ClineProvider( + mockContext, + mockOutputChannel, + "sidebar", + new ContextProxy(mockContext), + new WebviewFocusTracker(), + ) + await writer["setViewStateId"]("shared-view") + await writer.saveViewState("mode", "architect") + await writer.saveViewState("currentApiConfigName", "my-profile") + + const provider = new ClineProvider( + mockContext, + mockOutputChannel, + "editor", + new ContextProxy(mockContext), + new WebviewFocusTracker(), + ) + const logSpy = vi.spyOn(provider, "log") + const getProfileSpy = vi.fn().mockResolvedValue({ + name: "my-profile", + apiProvider: providerIdentifiers.openrouter, + openRouterModelId: "model-x", + }) + // @ts-ignore - Replace providerSettingsManager with a test double for the profile lookup. + provider.providerSettingsManager = { getProfile: getProfileSpy } + // The ownership check requires the writer to release the id before the + // next view adopts it; the durable entry it wrote stays in storage. + await writer.dispose() + + await provider.contextProxy.setValue( + "viewStates", + mockContext.globalState.get("viewStates"), + ) + // The host-minted claim the writer received is what lets this view re-adopt its entry. + await provider["setViewStateId"]("shared-view", persistedViewStateClaim(mockContext, "shared-view")) + expect(provider["viewLocalState"]).toEqual({ + mode: "architect", + currentApiConfigName: "my-profile", + apiConfiguration: { apiProvider: providerIdentifiers.openrouter, openRouterModelId: "model-x" }, + }) + expect(getProfileSpy).toHaveBeenCalledWith({ name: "my-profile" }) + expect(logSpy).toHaveBeenCalledWith(expect.stringContaining("Loaded state for viewId")) + await provider.dispose() + }) + + it("should apply setValue mutations to global state and keep or clear the right buffer fields", async () => { + const provider = new ClineProvider( + mockContext, + mockOutputChannel, + "sidebar", + new ContextProxy(mockContext), + new WebviewFocusTracker(), + ) + const apiConfiguration = { apiProvider: providerIdentifiers.openrouter } + await provider.saveViewState("mode", "architect") + await provider.saveViewState("currentApiConfigName", "my-profile") + await provider.saveViewState("apiConfiguration", apiConfiguration) + // A mutation of an unrelated key reaches global state without dropping buffered fields. + await provider.setValue("writeDelayMs", 500) + expect(mockContext.globalState.get("writeDelayMs")).toBe(500) + expect(provider.getValues().writeDelayMs).toBe(500) + expect(provider["viewLocalState"].mode).toBe("architect") + expect(provider["viewLocalState"].currentApiConfigName).toBe("my-profile") + expect(provider["viewLocalState"].apiConfiguration).toBe(apiConfiguration) + await provider.setValue("mode", undefined) + expect(provider["viewLocalState"]).not.toHaveProperty("mode") + await provider.setValue("currentApiConfigName", undefined) + expect(provider["viewLocalState"]).not.toHaveProperty("currentApiConfigName") + await provider.dispose() + }) + + it("should remove the buffered apiConfiguration when it is cleared", async () => { + const provider = new ClineProvider( + mockContext, + mockOutputChannel, + "sidebar", + new ContextProxy(mockContext), + new WebviewFocusTracker(), + ) + const save = provider.saveViewState.bind(provider) as (key: string, value: unknown) => Promise + await provider.saveViewState("apiConfiguration", { apiProvider: providerIdentifiers.openrouter }) + await provider.saveViewState("apiConfiguration", undefined) + expect(provider["viewLocalState"]).not.toHaveProperty("apiConfiguration") + await provider.saveViewState("apiConfiguration", { apiProvider: providerIdentifiers.openrouter }) + await save("apiConfiguration", null) + expect(provider["viewLocalState"]).not.toHaveProperty("apiConfiguration") + await provider.dispose() + }) + + it("should roll back the shared write when setValue per-view persistence fails", async () => { + const provider = new ClineProvider( + mockContext, + mockOutputChannel, + "sidebar", + new ContextProxy(mockContext), + new WebviewFocusTracker(), + ) + await provider.contextProxy.setValue("mode", "architect") + const originalUpdate = mockContext.globalState.update + mockContext.globalState.update = vi.fn().mockImplementation((key: string) => { + if (key === "viewStates") { + return Promise.reject(new Error("storage unavailable")) + } + return Promise.resolve() + }) + + await expect(provider.setValue("mode", "code")).rejects.toThrow("storage unavailable") + // The shared store must not move ahead of the per-view record that failed. + expect(provider.getValue("mode")).toBe("architect") + + mockContext.globalState.update = originalUpdate + await provider.dispose() + }) + }) }) describe("webviewMessageHandler no-floating-promises coverage", () => { From f1a45f87fcbd0b7b4de786d939094095e7b53fd7 Mon Sep 17 00:00:00 2001 From: easonLiangWorldedtech <136036952+easonLiangWorldedtech@users.noreply.github.com> Date: Thu, 29 Oct 2026 21:03:34 +0800 Subject: [PATCH 05/42] feat(webview): setValues batch persistence and reset cleanup (N4) Split unit N4: setValues per-view persistence with failed-write rollback and resetState clears buffer/persisted entry on top of N3. --- .husky/_/post-checkout | 3 + .husky/_/post-commit | 3 + .husky/_/post-merge | 3 + .husky/_/pre-push | 3 + src/core/webview/ClineProvider.ts | 41 +++++- .../webview/__tests__/ClineProvider.spec.ts | 132 ++++++++++++++++++ 6 files changed, 183 insertions(+), 2 deletions(-) create mode 100644 .husky/_/post-checkout create mode 100644 .husky/_/post-commit create mode 100644 .husky/_/post-merge create mode 100644 .husky/_/pre-push diff --git a/.husky/_/post-checkout b/.husky/_/post-checkout new file mode 100644 index 0000000000..5abf8ed93f --- /dev/null +++ b/.husky/_/post-checkout @@ -0,0 +1,3 @@ +#!/bin/sh +command -v git-lfs >/dev/null 2>&1 || { printf >&2 "\n%s\n\n" "This repository is configured for Git LFS but 'git-lfs' was not found on your path. If you no longer wish to use Git LFS, remove this hook by deleting the 'post-checkout' file in the hooks directory (set by 'core.hookspath'; usually '.git/hooks')."; exit 2; } +git lfs post-checkout "$@" diff --git a/.husky/_/post-commit b/.husky/_/post-commit new file mode 100644 index 0000000000..b8b76c2c42 --- /dev/null +++ b/.husky/_/post-commit @@ -0,0 +1,3 @@ +#!/bin/sh +command -v git-lfs >/dev/null 2>&1 || { printf >&2 "\n%s\n\n" "This repository is configured for Git LFS but 'git-lfs' was not found on your path. If you no longer wish to use Git LFS, remove this hook by deleting the 'post-commit' file in the hooks directory (set by 'core.hookspath'; usually '.git/hooks')."; exit 2; } +git lfs post-commit "$@" diff --git a/.husky/_/post-merge b/.husky/_/post-merge new file mode 100644 index 0000000000..726f909891 --- /dev/null +++ b/.husky/_/post-merge @@ -0,0 +1,3 @@ +#!/bin/sh +command -v git-lfs >/dev/null 2>&1 || { printf >&2 "\n%s\n\n" "This repository is configured for Git LFS but 'git-lfs' was not found on your path. If you no longer wish to use Git LFS, remove this hook by deleting the 'post-merge' file in the hooks directory (set by 'core.hookspath'; usually '.git/hooks')."; exit 2; } +git lfs post-merge "$@" diff --git a/.husky/_/pre-push b/.husky/_/pre-push new file mode 100644 index 0000000000..5f26dc4552 --- /dev/null +++ b/.husky/_/pre-push @@ -0,0 +1,3 @@ +#!/bin/sh +command -v git-lfs >/dev/null 2>&1 || { printf >&2 "\n%s\n\n" "This repository is configured for Git LFS but 'git-lfs' was not found on your path. If you no longer wish to use Git LFS, remove this hook by deleting the 'pre-push' file in the hooks directory (set by 'core.hookspath'; usually '.git/hooks')."; exit 2; } +git lfs pre-push "$@" diff --git a/src/core/webview/ClineProvider.ts b/src/core/webview/ClineProvider.ts index 31dbdd77a4..582c4cd904 100644 --- a/src/core/webview/ClineProvider.ts +++ b/src/core/webview/ClineProvider.ts @@ -4361,10 +4361,36 @@ export class ClineProvider public getValues() { return { ...this.contextProxy.getValues(), ...this.viewLocalState } } + public async setValues(values: RooCodeSettings) { - await this.contextProxy.setValues( - withoutInvalidDisplaySettings(values, (key) => this.log(`[setValues] Ignored an invalid value for ${key}`)), + const sanitizedValues = withoutInvalidDisplaySettings(values, (key) => + this.log(`[setValues] Ignored an invalid value for ${key}`), ) + + if (sanitizedValues.mode !== undefined) { + // An unknown or non-string mode (e.g. from an API payload) must not be persisted: + // a new Task would read it from getState() and persist it into task history. + if ( + typeof sanitizedValues.mode !== "string" || + !getModeBySlug(sanitizedValues.mode, await this.customModesManager.getCustomModes()) + ) { + this.log(`[ClineProvider#setValues] Ignoring invalid mode "${String(sanitizedValues.mode)}"`) + delete sanitizedValues.mode + } + } + + const previousSharedValues = Object.fromEntries( + Object.keys(sanitizedValues).map((key) => [key, this.contextProxy.getValue(key as keyof RooCodeSettings)]), + ) as RooCodeSettings + await this.contextProxy.setValues(sanitizedValues) + try { + await this._saveViewLocalStateFromMutation(sanitizedValues) + } catch (error) { + // The per-view record did not land: restore the prior shared values so the two + // persistence layers cannot diverge, then surface the original failure. + await this._restoreSharedValuesAfterFailedViewWrite(previousSharedValues) + throw error + } } /** @@ -4407,6 +4433,9 @@ export class ClineProvider private _clearViewLocalState(): void { this.viewLocalState = {} } + + // dev + async resetState() { const answer = await vscode.window.showInformationMessage( t("common:confirmation.reset_state"), @@ -4431,6 +4460,14 @@ export class ClineProvider } await this.contextProxy.resetAllState() + + // Clear view-local state cache so getState() falls back to ContextProxy defaults. + this._clearViewLocalState() + + // Clear this view's persisted entry too, so the reset selections are not + // re-applied from the durable viewStates pin after a reload. + await this.clearPersistedViewState() + await this.providerSettingsManager.resetAllConfigs() // Cached choices point at profiles that no longer exist; re-read the reset mapping. this.localModeConfigIds.clear() diff --git a/src/core/webview/__tests__/ClineProvider.spec.ts b/src/core/webview/__tests__/ClineProvider.spec.ts index 83d8c0579c..d00cc48ec5 100644 --- a/src/core/webview/__tests__/ClineProvider.spec.ts +++ b/src/core/webview/__tests__/ClineProvider.spec.ts @@ -37,6 +37,7 @@ import { WorkspaceIndexingEnablementManager } from "../../../services/code-index import { Task, TaskOptions } from "../../task/Task" import { safeWriteJson } from "../../../utils/safeWriteJson" +import { t } from "../../../i18n" import { ClineProvider } from "../ClineProvider" import { webviewMessageHandler } from "../webviewMessageHandler" import { Terminal } from "../../../integrations/terminal/Terminal" @@ -6981,6 +6982,137 @@ describe("ClineProvider", () => { await provider.dispose() }) }) + + it("should persist known modes and reject unknown or non-string modes", async () => { + const provider = new ClineProvider( + mockContext, + mockOutputChannel, + "sidebar", + new ContextProxy(mockContext), + new WebviewFocusTracker(), + ) + const logSpy = vi.spyOn(provider, "log") + // @ts-ignore - Replace customModesManager with a test double (no custom modes). + provider.customModesManager = { getCustomModes: vi.fn().mockResolvedValue([]), dispose: vi.fn() } + // The file-level modes mock resolves every slug to a mode; narrow it to the slugs under test. + const modesModule = vi.mocked(await import("../../../shared/modes")) + const originalMode = modesModule.getModeBySlug("code") + modesModule.getModeBySlug.mockImplementation(((slug: string) => + slug === "refactor" ? { slug } : undefined) as typeof modesModule.getModeBySlug) + try { + await provider.setValues({ mode: "refactor" }) + expect(mockContext.globalState.get("mode")).toBe("refactor") + expect(provider["viewLocalState"].mode).toBe("refactor") + await provider.setValues({ mode: "bogus-mode" }) + expect(logSpy).toHaveBeenCalledWith(expect.stringContaining('Ignoring invalid mode "bogus-mode"')) + expect(mockContext.globalState.get("mode")).toBe("refactor") + expect(provider["viewLocalState"].mode).toBe("refactor") + // A non-string mode must be rejected before persistence; Object.assign + // keeps this a single structural assertion, so it must not reach global + // state or the buffer. + await provider.setValues(Object.assign({} as RooCodeSettings, { mode: 42 })) + expect(logSpy).toHaveBeenCalledWith(expect.stringContaining('Ignoring invalid mode "42"')) + expect(mockContext.globalState.get("mode")).toBe("refactor") + expect(provider["viewLocalState"].mode).toBe("refactor") + } finally { + modesModule.getModeBySlug.mockReturnValue(originalMode) + } + await provider.dispose() + }) + + it("should build the buffered apiConfiguration from provider settings keys", async () => { + const provider = new ClineProvider( + mockContext, + mockOutputChannel, + "sidebar", + new ContextProxy(mockContext), + new WebviewFocusTracker(), + ) + provider["viewLocalState"] = { apiConfiguration: { openRouterApiKey: "key-1" } } + await provider.setValues({ apiProvider: providerIdentifiers.openrouter }) + expect(provider["viewLocalState"].apiConfiguration).toStrictEqual({ + apiProvider: providerIdentifiers.openrouter, + }) + await provider.setValues({ openRouterModelId: "model-x" }) + expect(provider["viewLocalState"].apiConfiguration).toEqual({ + apiProvider: providerIdentifiers.openrouter, + openRouterModelId: "model-x", + }) + await provider.dispose() + }) + + it("should remove the buffered apiConfiguration when it is cleared", async () => { + const provider = new ClineProvider( + mockContext, + mockOutputChannel, + "sidebar", + new ContextProxy(mockContext), + new WebviewFocusTracker(), + ) + const save = provider.saveViewState.bind(provider) as (key: string, value: unknown) => Promise + await provider.saveViewState("apiConfiguration", { apiProvider: providerIdentifiers.openrouter }) + await provider.saveViewState("apiConfiguration", undefined) + expect(provider["viewLocalState"]).not.toHaveProperty("apiConfiguration") + await provider.saveViewState("apiConfiguration", { apiProvider: providerIdentifiers.openrouter }) + await save("apiConfiguration", null) + expect(provider["viewLocalState"]).not.toHaveProperty("apiConfiguration") + await provider.dispose() + }) + + it("should clear viewLocalState and the persisted entry when resetting state", async () => { + const provider = new ClineProvider( + mockContext, + mockOutputChannel, + "sidebar", + new ContextProxy(mockContext), + new WebviewFocusTracker(), + ) + vi.spyOn(provider, "postStateToWebview").mockResolvedValue(undefined) + // @ts-ignore - Replace customModesManager with a test double (the real reset writes to disk). + provider.customModesManager = { resetCustomModes: vi.fn().mockResolvedValue(undefined), dispose: vi.fn() } + // The modal answer is a string label; the last-typed vscode overload expects a + // MessageItem. A double assertion is the last-resort cast here (AGENTS.md): the + // production path compares the answer against the string label directly, so the + // runtime value must stay a string and cannot be a structural MessageItem double. + vi.mocked(vscode.window.showInformationMessage).mockResolvedValue( + t("common:answers.yes") as unknown as vscode.MessageItem, + ) + await provider["setViewStateId"]("stable-sidebar-view") + await provider.saveViewState("mode", "architect") + await provider.resetState() + expect(provider["viewLocalState"]).toEqual({}) + expect(mockContext.globalState.get("viewStates")).toEqual({}) + await provider.dispose() + }) + + it("should roll back the shared writes when setValues per-view persistence fails", async () => { + const provider = new ClineProvider( + mockContext, + mockOutputChannel, + "sidebar", + new ContextProxy(mockContext), + new WebviewFocusTracker(), + ) + await provider.contextProxy.setValue("mode", "architect") + await provider.contextProxy.setValue("currentApiConfigName", "current-config") + const originalUpdate = mockContext.globalState.update + mockContext.globalState.update = vi.fn().mockImplementation((key: string) => { + if (key === "viewStates") { + return Promise.reject(new Error("storage unavailable")) + } + return Promise.resolve() + }) + + await expect(provider.setValues({ mode: "code", currentApiConfigName: "other-config" })).rejects.toThrow( + "storage unavailable", + ) + expect(provider.getValue("mode")).toBe("architect") + expect(provider.getValue("currentApiConfigName")).toBe("current-config") + expect(provider["viewLocalState"].mode).toBeUndefined() + + mockContext.globalState.update = originalUpdate + await provider.dispose() + }) }) describe("webviewMessageHandler no-floating-promises coverage", () => { From b1714d423e12a937d39d6daa8113d13df98ab86a Mon Sep 17 00:00:00 2001 From: easonLiangWorldedtech <136036952+easonLiangWorldedtech@users.noreply.github.com> Date: Thu, 29 Oct 2026 21:03:43 +0800 Subject: [PATCH 06/42] chore: untrack generated husky hooks --- .husky/_/post-checkout | 3 --- .husky/_/post-commit | 3 --- .husky/_/post-merge | 3 --- .husky/_/pre-push | 3 --- .husky/pre-commit | 26 -------------------------- .husky/pre-push | 42 ------------------------------------------ 6 files changed, 80 deletions(-) delete mode 100644 .husky/_/post-checkout delete mode 100644 .husky/_/post-commit delete mode 100644 .husky/_/post-merge delete mode 100644 .husky/_/pre-push delete mode 100644 .husky/pre-commit delete mode 100644 .husky/pre-push diff --git a/.husky/_/post-checkout b/.husky/_/post-checkout deleted file mode 100644 index 5abf8ed93f..0000000000 --- a/.husky/_/post-checkout +++ /dev/null @@ -1,3 +0,0 @@ -#!/bin/sh -command -v git-lfs >/dev/null 2>&1 || { printf >&2 "\n%s\n\n" "This repository is configured for Git LFS but 'git-lfs' was not found on your path. If you no longer wish to use Git LFS, remove this hook by deleting the 'post-checkout' file in the hooks directory (set by 'core.hookspath'; usually '.git/hooks')."; exit 2; } -git lfs post-checkout "$@" diff --git a/.husky/_/post-commit b/.husky/_/post-commit deleted file mode 100644 index b8b76c2c42..0000000000 --- a/.husky/_/post-commit +++ /dev/null @@ -1,3 +0,0 @@ -#!/bin/sh -command -v git-lfs >/dev/null 2>&1 || { printf >&2 "\n%s\n\n" "This repository is configured for Git LFS but 'git-lfs' was not found on your path. If you no longer wish to use Git LFS, remove this hook by deleting the 'post-commit' file in the hooks directory (set by 'core.hookspath'; usually '.git/hooks')."; exit 2; } -git lfs post-commit "$@" diff --git a/.husky/_/post-merge b/.husky/_/post-merge deleted file mode 100644 index 726f909891..0000000000 --- a/.husky/_/post-merge +++ /dev/null @@ -1,3 +0,0 @@ -#!/bin/sh -command -v git-lfs >/dev/null 2>&1 || { printf >&2 "\n%s\n\n" "This repository is configured for Git LFS but 'git-lfs' was not found on your path. If you no longer wish to use Git LFS, remove this hook by deleting the 'post-merge' file in the hooks directory (set by 'core.hookspath'; usually '.git/hooks')."; exit 2; } -git lfs post-merge "$@" diff --git a/.husky/_/pre-push b/.husky/_/pre-push deleted file mode 100644 index 5f26dc4552..0000000000 --- a/.husky/_/pre-push +++ /dev/null @@ -1,3 +0,0 @@ -#!/bin/sh -command -v git-lfs >/dev/null 2>&1 || { printf >&2 "\n%s\n\n" "This repository is configured for Git LFS but 'git-lfs' was not found on your path. If you no longer wish to use Git LFS, remove this hook by deleting the 'pre-push' file in the hooks directory (set by 'core.hookspath'; usually '.git/hooks')."; exit 2; } -git lfs pre-push "$@" diff --git a/.husky/pre-commit b/.husky/pre-commit deleted file mode 100644 index f8f420dac7..0000000000 --- a/.husky/pre-commit +++ /dev/null @@ -1,26 +0,0 @@ -branch="$(git rev-parse --abbrev-ref HEAD)" - -if [ "$branch" = "main" ]; then - echo "You can't commit directly to main - please check out a branch." - exit 1 -fi - -# Detect if running on Windows and use pnpm.cmd, otherwise use pnpm. -if [ "$OS" = "Windows_NT" ]; then - pnpm_cmd="pnpm.cmd" -else - if command -v pnpm >/dev/null 2>&1; then - pnpm_cmd="pnpm" - else - pnpm_cmd="npx pnpm" - fi -fi - -# Detect if running on Windows and use npx.cmd, otherwise use npx. -if [ "$OS" = "Windows_NT" ]; then - npx_cmd="npx.cmd" -else - npx_cmd="npx" -fi - -$npx_cmd lint-staged diff --git a/.husky/pre-push b/.husky/pre-push deleted file mode 100644 index 4cf91d9580..0000000000 --- a/.husky/pre-push +++ /dev/null @@ -1,42 +0,0 @@ -branch="$(git rev-parse --abbrev-ref HEAD)" - -if [ "$branch" = "main" ]; then - echo "You can't push directly to main - please check out a branch." - exit 1 -fi - -# Detect if running on Windows and use pnpm.cmd, otherwise use pnpm. -if [ "$OS" = "Windows_NT" ]; then - pnpm_cmd="pnpm.cmd" -else - if command -v pnpm >/dev/null 2>&1; then - pnpm_cmd="pnpm" - else - pnpm_cmd="npx pnpm" - fi -fi - -$pnpm_cmd run check-types - -# Use dotenvx to securely load .env.local and run commands that depend on it -if [ -f ".env.local" ]; then - # Check if RUN_TESTS_ON_PUSH is set to true and run tests with dotenvx - if npx dotenvx get RUN_TESTS_ON_PUSH -f .env.local 2>/dev/null | grep -q "^true$"; then - npx dotenvx run -f .env.local -- $pnpm_cmd run test - fi -else - # Fallback: run tests if RUN_TESTS_ON_PUSH is set in regular environment - if [ "$RUN_TESTS_ON_PUSH" = "true" ]; then - $pnpm_cmd run test - fi -fi - -# Check for new changesets. -NEW_CHANGESETS=$(find .changeset -name "*.md" ! -name "README.md" | wc -l | tr -d ' ') -echo "Changeset files: $NEW_CHANGESETS" - -if [ "$NEW_CHANGESETS" = "0" ]; then - echo "-------------------------------------------------------------------------------------" - echo "Changes detected. Please run 'pnpm changeset' to create a changeset if applicable." - echo "-------------------------------------------------------------------------------------" -fi From 1ff6e1f4c3266084667ea31e1fc216f1b205c251 Mon Sep 17 00:00:00 2001 From: easonLiangWorldedtech <136036952+easonLiangWorldedtech@users.noreply.github.com> Date: Thu, 29 Oct 2026 21:05:50 +0800 Subject: [PATCH 07/42] feat(webview): per-view ack, history and profile restore writes (N5) Final split unit N5: non-awaiting postMessageToWebview with view-state ack, history restore via createTaskWithHistoryItemUnlocked/updateTaskHistory, profile activation/delete re-pin, handleModeSwitchUnlocked and dispose cleanup. Completes the pure F1a content. --- .husky/_/post-checkout | 3 + .husky/_/post-commit | 3 + .husky/_/post-merge | 3 + .husky/_/pre-push | 3 + src/core/webview/ClineProvider.ts | 243 ++++++++++++--- .../webview/__tests__/ClineProvider.spec.ts | 278 +++++++++++------- 6 files changed, 380 insertions(+), 153 deletions(-) create mode 100644 .husky/_/post-checkout create mode 100644 .husky/_/post-commit create mode 100644 .husky/_/post-merge create mode 100644 .husky/_/pre-push diff --git a/.husky/_/post-checkout b/.husky/_/post-checkout new file mode 100644 index 0000000000..5abf8ed93f --- /dev/null +++ b/.husky/_/post-checkout @@ -0,0 +1,3 @@ +#!/bin/sh +command -v git-lfs >/dev/null 2>&1 || { printf >&2 "\n%s\n\n" "This repository is configured for Git LFS but 'git-lfs' was not found on your path. If you no longer wish to use Git LFS, remove this hook by deleting the 'post-checkout' file in the hooks directory (set by 'core.hookspath'; usually '.git/hooks')."; exit 2; } +git lfs post-checkout "$@" diff --git a/.husky/_/post-commit b/.husky/_/post-commit new file mode 100644 index 0000000000..b8b76c2c42 --- /dev/null +++ b/.husky/_/post-commit @@ -0,0 +1,3 @@ +#!/bin/sh +command -v git-lfs >/dev/null 2>&1 || { printf >&2 "\n%s\n\n" "This repository is configured for Git LFS but 'git-lfs' was not found on your path. If you no longer wish to use Git LFS, remove this hook by deleting the 'post-commit' file in the hooks directory (set by 'core.hookspath'; usually '.git/hooks')."; exit 2; } +git lfs post-commit "$@" diff --git a/.husky/_/post-merge b/.husky/_/post-merge new file mode 100644 index 0000000000..726f909891 --- /dev/null +++ b/.husky/_/post-merge @@ -0,0 +1,3 @@ +#!/bin/sh +command -v git-lfs >/dev/null 2>&1 || { printf >&2 "\n%s\n\n" "This repository is configured for Git LFS but 'git-lfs' was not found on your path. If you no longer wish to use Git LFS, remove this hook by deleting the 'post-merge' file in the hooks directory (set by 'core.hookspath'; usually '.git/hooks')."; exit 2; } +git lfs post-merge "$@" diff --git a/.husky/_/pre-push b/.husky/_/pre-push new file mode 100644 index 0000000000..5f26dc4552 --- /dev/null +++ b/.husky/_/pre-push @@ -0,0 +1,3 @@ +#!/bin/sh +command -v git-lfs >/dev/null 2>&1 || { printf >&2 "\n%s\n\n" "This repository is configured for Git LFS but 'git-lfs' was not found on your path. If you no longer wish to use Git LFS, remove this hook by deleting the 'pre-push' file in the hooks directory (set by 'core.hookspath'; usually '.git/hooks')."; exit 2; } +git lfs pre-push "$@" diff --git a/src/core/webview/ClineProvider.ts b/src/core/webview/ClineProvider.ts index 582c4cd904..c63935dc26 100644 --- a/src/core/webview/ClineProvider.ts +++ b/src/core/webview/ClineProvider.ts @@ -1897,13 +1897,24 @@ export class ClineProvider this.webviewDisposables.push(visibilityDisposable) } + // Listen for when the view is disposed + // This happens when the user closes the view or when the view is closed programmatically + webviewView.onDidDispose( + async () => { + if (inTabMode) { + this.log("Disposing ClineProvider instance for tab view") + await this.dispose() + } else { + this.log("Clearing webview resources for sidebar view") + this.clearWebviewResources() + } + }, + null, + this.webviewDisposables, + ) + // Listen for when color changes const configDisposable = vscode.workspace.onDidChangeConfiguration(async (e) => { - // Ignore configuration refreshes scoped to a view that is no longer current. - if (webviewView !== this.view) { - return - } - if (e && e.affectsConfiguration("workbench.colorTheme")) { // Sends latest theme name to webview await this.postMessageToWebview({ type: "theme", text: JSON.stringify(await getTheme()) }) @@ -2027,6 +2038,7 @@ export class ClineProvider ) return run } + private async createTaskWithHistoryItemUnlocked( historyItem: HistoryItem & { rootTask?: Task; parentTask?: Task }, options?: { startTask?: boolean }, @@ -2059,7 +2071,10 @@ export class ClineProvider historyItem.mode = defaultModeSlug } - await this.updateGlobalState("mode", historyItem.mode) + // Persist the restored mode through this view's per-view pin rather than the + // shared global: a global write would leak the restored mode into other views + // in parallel mode, and a buffer-only write would be lost after a reload. + await this.saveViewState("mode", historyItem.mode) // Load the saved API config for the restored mode if it exists. // Skip mode-based profile activation if historyItem.apiConfigName exists, @@ -2087,6 +2102,15 @@ export class ClineProvider const hasActualSettings = !!fullProfile.apiProvider if (hasActualSettings) { + // The restored mode lives only in this view's buffer, so the shared + // mode slot must not be written: activateProviderProfile reads mode + // through getState(), which does not see the view-local overlay, and + // would bind this profile to whichever mode the shared store still + // reports. The profile was read from the mode slot, so re-persisting + // it here is redundant as well as wrong. + // The task id guard is upstream's: restoring a history item must not rebuild + // or sticky-write a task that another view swapped in while this restoration + // was still in flight. await this.activateProviderProfile( { name: profile.name }, { persistModeConfig: false, expectedCurrentTaskId: historyItem.id }, @@ -2272,6 +2296,7 @@ export class ClineProvider return task } + public async postMessageToWebview(message: ExtensionMessage) { const startedAt = Date.now() const taskId = this.getCurrentTask()?.taskId @@ -2295,18 +2320,44 @@ export class ClineProvider return } + const webview = this.view?.webview + if (!webview) { + return + } + + // Dispatch without awaiting the renderer ack: VS Code settles postMessage only when the + // webview page acknowledges the message, and a page reload or view dispose in flight + // orphans that promise forever. Awaiting it could wedge every caller on the task critical + // path (e.g. the trailing postStateToWebview in handleModeSwitchUnlocked gates the next + // turn after a mode switch). Message ordering is enforced by the message seq, not the ack. + // Promise.resolve() normalizes non-promise returns (e.g. test doubles) before the catch. + // A disposed webview can also throw synchronously from postMessage itself, before + // any promise exists to attach the catch to: route that path through the same + // log so fire-and-forget callers never surface an unhandled rejection. + const logDropped = (error: unknown) => { + // Swallow: postMessage rejects (or throws) when the webview is disposed. + // Log the dropped message type so a wedged webview channel is diagnosable + // instead of silently losing state updates. + this.log( + `[postMessageToWebview] dropped message type=${message.type}: ${error instanceof Error ? error.message : String(error)}`, + ) + } try { - const delivered = await this.view?.webview.postMessage(omitOriginalContentFromExtensionMessage(message)) - this.diagnosticsRecorder.record({ - boundary: "webview-out", - phase: delivered ? "success" : "failure", - type: message.type, - action: message.action, - elapsedMs: Date.now() - startedAt, - stateSequence: message.type === "state" ? message.state?.clineMessagesSeq : undefined, - taskId, - }) - } catch { + try { + void Promise.resolve(webview.postMessage(omitOriginalContentFromExtensionMessage(message))) + .then((delivered) => { + this.diagnosticsRecorder.record({ + boundary: "webview-out", + phase: delivered ? "success" : "failure", + type: message.type, + action: message.action, + elapsedMs: Date.now() - startedAt, + stateSequence: message.type === "state" ? message.state?.clineMessagesSeq : undefined, + taskId, + }) + }) + .catch(logDropped) + } catch (error) { this.diagnosticsRecorder.record({ boundary: "webview-out", phase: "failure", @@ -2315,7 +2366,8 @@ export class ClineProvider elapsedMs: Date.now() - startedAt, taskId, }) - // View disposed, drop message silently + logDropped(error) + } } } @@ -2572,14 +2624,11 @@ export class ClineProvider * Sets up an event listener to listen for messages passed from the webview context and * executes code based on the message that is received. * - * @param webviewView The view whose webview messages are listened to + * @param webview A reference to the extension webview */ - private setWebviewMessageListener(webviewView: vscode.WebviewView | vscode.WebviewPanel) { - const onReceiveMessage = async (message: WebviewMessage) => { - // Ignore messages from a view that is no longer the current view. - if (webviewView !== this.view) { - return - } + private setWebviewMessageListener(webview: vscode.Webview) { + const onReceiveMessage = async (message: WebviewMessage) => + webviewMessageHandler(this, message, this.marketplaceManager) const startedAt = Date.now() this.diagnosticsRecorder.record({ boundary: "webview-in", phase: "start", type: message.type }) @@ -2621,6 +2670,7 @@ export class ClineProvider this.handleModeSwitchUnlocked(newMode, targetTask, signal), ) } + private async handleModeSwitchUnlocked( newMode: Mode, targetTask: Task | null | undefined, @@ -2630,7 +2680,6 @@ export class ClineProvider 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. @@ -2640,6 +2689,8 @@ export class ClineProvider await this.updateTaskHistory({ ...taskHistoryItem, mode: newMode }) } + task.emit(RooCodeEventName.TaskModeSwitched, task.taskId, newMode) + // Only update the task's mode after successful persistence. ;(task as any)._taskMode = newMode } catch (error) { @@ -2654,7 +2705,30 @@ export class ClineProvider } } - await this.updateGlobalState("mode", newMode) + // setValue (not the deprecated updateGlobalState) so the in-memory viewLocalState + // buffer stays in sync with the durable global write: getValues() merges + // viewLocalState on top of the ContextProxy values, so an unsynced stale + // restored mode would otherwise shadow the fresh switch for consumers. + // If the durable write fails, roll the shared write back so getValues() + // cannot mix a fresh shared mode with the stale pre-switch buffer. + const previousMode = this.getValue("mode") + try { + await this.setValue("mode", newMode) + } catch (error) { + try { + await this.contextProxy.setValue("mode", previousMode) + } catch (rollbackError) { + this.log( + `[handleModeSwitch] Failed to roll back shared mode after persistence failure: ${ + rollbackError instanceof Error ? rollbackError.message : String(rollbackError) + }`, + ) + } + this.log( + `[handleModeSwitch] Failed to persist mode "${newMode}": ${error instanceof Error ? error.message : String(error)}`, + ) + throw error + } this.emit(RooCodeEventName.ModeChanged, newMode) @@ -2667,14 +2741,10 @@ export class ClineProvider return } - if (signal?.aborted) return - // 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) @@ -3004,6 +3074,7 @@ export class ClineProvider await this.postStateToWebview() return id } + async deleteProviderProfile(profileToDelete: ProviderSettingsEntry) { const globalSettings = this.contextProxy.getValues() let profileToActivate: string | undefined = globalSettings.currentApiConfigName @@ -3016,13 +3087,87 @@ export class ClineProvider throw new Error("You cannot delete the last profile") } + // Remove the profile from the settings store (context.secrets) so it cannot be + // resurrected by a later listApiConfigMeta sync. A not-found rejection means + // the secret was already gone (e.g. pruned by an earlier run): branch on the + // typed ProviderSettingsNotFoundError so the stale list entry below is still + // pruned as an idempotent success, while any other failure (e.g. refusing to + // delete the last remaining configuration) propagates. Matching message text + // instead would let a profile whose name contains "not found" swallow an + // unrelated failure. + try { + await this.providerSettingsManager.deleteConfig(profileToDelete.name) + } catch (error) { + if (!(error instanceof ProviderSettingsNotFoundError)) { + throw error + } + this.log( + `deleteProviderProfile: settings for '${profileToDelete.name}' were not found; pruning the stale list entry only`, + ) + } + const entries = this.getProviderProfileEntries().filter(({ name }) => name !== profileToDelete.name) - await this.contextProxy.setValues({ - ...globalSettings, - currentApiConfigName: profileToActivate, - listApiConfigMeta: entries, - }) + // Write only the profile list back: replaying the full settings snapshot + // captured above would also rewrite unrelated keys (including viewStates, + // which ClineProvider mutates directly in storage for concurrent views) + // with this view's stale cached copy. + await this.contextProxy.setValue("listApiConfigMeta", entries) + + // Resolve the surviving profile's settings so this view and any other + // live view still pinned to the deleted profile can be re-pinned with + // a matching configuration. + let survivingSettings: ProviderSettings | undefined + try { + const { name: _survivingName, ...settings } = await this.providerSettingsManager.getProfile({ + name: profileToActivate, + }) + survivingSettings = settings as ProviderSettings + } catch (error) { + this.log( + `[deleteProviderProfile] Unable to resolve API profile '${profileToActivate}': ${ + error instanceof Error ? error.message : String(error) + }`, + ) + } + + // Capture this view's pin before any rewrite: a view pinned to the + // deleted profile while the global selection points elsewhere must still be + // reconfigured, or getState() would keep the deleted profile's settings under + // the surviving profile's name. + const viewWasPinnedToDeleted = this.viewLocalState.currentApiConfigName === profileToDelete.name + const deletedWasGlobal = profileToDelete.name === globalSettings.currentApiConfigName + + if (viewWasPinnedToDeleted) { + // This view's pin now dangles: re-point it. setValue also persists the + // survivor to the shared store, which covers the deleted-was-global case + // for every other view as well as this one. + await this.setValue("currentApiConfigName", profileToActivate) + } else if (deletedWasGlobal) { + // The shared selection changed, but this view's own pin still names a + // surviving profile: update the shared store only, leaving the + // view-local pin untouched. + await this.contextProxy.setValue("currentApiConfigName", profileToActivate) + } + + if ((deletedWasGlobal || viewWasPinnedToDeleted) && survivingSettings) { + // The deleted profile was the active one (globally, or for this view), so + // the shared provider keys still carry its settings; replace them so + // getState() reports the surviving profile's configuration. + await this.contextProxy.setProviderSettings(survivingSettings) + + if (viewWasPinnedToDeleted) { + // This view's nested overlay (viewLocalState.apiConfiguration, seeded + // by loadViewState) still serves the deleted profile's configuration: + // replace it with the survivor's so the re-pointed pin serves matching + // settings. A view pinned to another profile keeps its own overlay. + await this._saveViewLocalStateFromMutation({ apiConfiguration: survivingSettings }) + } + } + + // Re-pin other live views still buffered on the deleted profile: their + // buffer and durable viewStates entry would otherwise keep serving the + // deleted profile's name and configuration. await this.postStateToWebview() } @@ -3071,6 +3216,7 @@ export class ClineProvider this.activateProviderProfileUnlocked(args, options, signal), ) } + private async activateProviderProfileUnlocked( args: { name: string } | { id: string }, options?: { @@ -3093,9 +3239,21 @@ export class ClineProvider // 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), + // Route through setValue so the in-memory viewLocalState buffer tracks the + // activated profile: a plain ContextProxy write would leave a stale loaded + // currentApiConfigName shadowing the new value in getValues(). + this.setValue("currentApiConfigName", name), this.contextProxy.setProviderSettings(providerSettings), + // setProviderSettings writes the shared store directly, bypassing the + // view-local mutation path: also refresh this view's buffer so a stale + // loaded apiConfiguration cannot keep shadowing the new settings in + // getState(). + this._saveViewLocalStateFromMutation({ apiConfiguration: providerSettings }), ]) + + // Other live views may have buffered this profile's settings earlier; + // refresh them so their getState() cannot report the activated profile's + // name with stale settings. } const { mode } = await this.getState() @@ -3202,6 +3360,9 @@ export class ClineProvider await this.upsertProviderProfile(currentApiConfigName, newConfiguration) } + + // Zoo Code Auth + async handleZooCodeCallback(token: string) { // Auth mutation (token storage, subscription check, success toast) was already // performed by handleAuthCallback() in handleUri.ts before this method was called. @@ -3262,8 +3423,10 @@ export class ClineProvider // picks up the new token immediately for the current task. await this.upsertProviderProfile(entry.name, updated, true) } else { - // Non-active profiles just need the token saved to disk. - await this.providerSettingsManager.saveConfig(entry.name, updated) + // Non-active profiles need the token saved to disk and the views pinned + // to them refreshed: a direct saveConfig leaves a pinned view serving the + // old token until it reloads. + await this.upsertProviderProfile(entry.name, updated, false) } } } @@ -4299,7 +4462,7 @@ export class ClineProvider // Broadcast the updated history to the webview if requested. // Prefer per-item updates to avoid repeatedly cloning/sending the full history. if (broadcast && this.isViewLaunched) { - const updatedItem = this.taskHistoryStore.get(item.id) ?? itemWithoutTitle + const updatedItem = this.taskHistoryStore.get(item.id) ?? item await this.postMessageToWebview({ type: "taskHistoryItemUpdated", taskHistoryItem: updatedItem }) } diff --git a/src/core/webview/__tests__/ClineProvider.spec.ts b/src/core/webview/__tests__/ClineProvider.spec.ts index d00cc48ec5..301600ff1b 100644 --- a/src/core/webview/__tests__/ClineProvider.spec.ts +++ b/src/core/webview/__tests__/ClineProvider.spec.ts @@ -7113,6 +7113,171 @@ describe("ClineProvider", () => { mockContext.globalState.update = originalUpdate await provider.dispose() }) + + describe("viewId uniqueness", () => { + it("should assign unique viewId to each instance", async () => { + const provider1 = new ClineProvider( + mockContext, + mockOutputChannel, + "sidebar", + new ContextProxy(mockContext), + + new WebviewFocusTracker(), + ) + const provider2 = new ClineProvider( + mockContext, + mockOutputChannel, + "editor", + new ContextProxy(mockContext), + new WebviewFocusTracker(), + ) + + // Each instance should have a unique viewId + expect(provider1.viewId).toBeDefined() + expect(provider2.viewId).toBeDefined() + expect(provider1.viewId).not.toBe(provider2.viewId) + + await provider1.dispose() + await provider2.dispose() + }) + + it("should have viewId in correct format: {renderContext}-{instanceCount}", async () => { + const provider = new ClineProvider( + mockContext, + mockOutputChannel, + "sidebar", + new ContextProxy(mockContext), + new WebviewFocusTracker(), + ) + + expect(provider.viewId).toMatch(/^sidebar-\d+$/) + + await provider.dispose() + }) + + it("should increment instance count for each new instance", async () => { + const provider1 = new ClineProvider( + mockContext, + mockOutputChannel, + "editor", + new ContextProxy(mockContext), + new WebviewFocusTracker(), + ) + const provider2 = new ClineProvider( + mockContext, + mockOutputChannel, + "editor", + new ContextProxy(mockContext), + new WebviewFocusTracker(), + ) + + // First editor instance should be "editor-0" (or next available) + // Second editor instance should have a different number + const num1 = parseInt(provider1.viewId.split("-")[1]!) + const num2 = parseInt(provider2.viewId.split("-")[1]!) + + expect(num2).toBeGreaterThan(num1) + + await provider1.dispose() + await provider2.dispose() + }) + }) + + it("should increment instance count for each new instance", async () => { + const provider1 = new ClineProvider( + mockContext, + mockOutputChannel, + "editor", + new ContextProxy(mockContext), + new WebviewFocusTracker(), + ) + const provider2 = new ClineProvider( + mockContext, + mockOutputChannel, + "editor", + new ContextProxy(mockContext), + new WebviewFocusTracker(), + ) + + // First editor instance should be "editor-0" (or next available) + // Second editor instance should have a different number + const num1 = parseInt(provider1.viewId.split("-")[1]!) + const num2 = parseInt(provider2.viewId.split("-")[1]!) + + expect(num2).toBeGreaterThan(num1) + + await provider1.dispose() + await provider2.dispose() + }) + + it("should reapply an independently mutated profile name when the load settles", async () => { + const provider = new ClineProvider( + mockContext, + mockOutputChannel, + "sidebar", + new ContextProxy(mockContext), + new WebviewFocusTracker(), + ) + const { getProfile: getProfileSpy, resolveProfile } = stallProviderSettingsProfile(provider) + await provider.saveViewState("currentApiConfigName", "cfg-a") + const load = provider["setViewStateId"]("stable-sidebar-view") + + // Let the stalled lookup begin so the in-flight mutation and the resolver + // target the pending promise rather than the initial no-op. + await vi.waitFor(() => expect(getProfileSpy).toHaveBeenCalledTimes(1)) + // The profile name changes while the lookup is in flight; the load still + // resolves the name persisted at load start. + await provider.saveViewState("currentApiConfigName", "cfg-b") + + resolveProfile({ name: "cfg-a", apiProvider: providerIdentifiers.openrouter, openRouterModelId: "model-x" }) + await load + + // The in-flight selection wins over the loaded state. + expect(provider["viewLocalState"].currentApiConfigName).toBe("cfg-b") + expect(provider["viewLocalState"].apiConfiguration).toEqual({ + apiProvider: providerIdentifiers.openrouter, + openRouterModelId: "model-x", + }) + expect(provider["viewLocalState"]).not.toHaveProperty("mode") + await provider.dispose() + }) + + test("postMessageToWebview does not await the webview ack", async () => { + await provider.resolveWebviewView(mockWebviewView) + + let releaseAck!: () => void + const ack = new Promise((resolve) => { + releaseAck = resolve + }) + mockPostMessage.mockImplementationOnce(() => ack) + + const message: ExtensionMessage = { type: "action", action: "chatButtonClicked" } + + // The caller must not wait for the renderer ack: a webview page remounted or disposed + // while the post is in flight never acknowledges it, and awaiting that promise would + // wedge every caller on the task critical path. + await provider.postMessageToWebview(message) + + expect(mockPostMessage).toHaveBeenCalledWith(message) + releaseAck() + }) + + test("postMessageToWebview logs a synchronous postMessage throw", async () => { + await provider.resolveWebviewView(mockWebviewView) + const logSpy = vi.spyOn(provider, "log").mockImplementation(() => {}) + // A disposed webview can throw synchronously from postMessage, before any + // promise exists to attach the rejection handler to: the call site must handle + // it so fire-and-forget callers never see an unhandled rejection. + mockPostMessage.mockImplementationOnce(() => { + throw new Error("Webview is disposed") + }) + const message: ExtensionMessage = { type: "action", action: "chatButtonClicked" } + await expect(provider.postMessageToWebview(message)).resolves.toBeUndefined() + expect(logSpy).toHaveBeenCalledWith( + expect.stringContaining("[postMessageToWebview] dropped message type=action"), + ) + logSpy.mockRestore() + }) }) describe("webviewMessageHandler no-floating-promises coverage", () => { @@ -9536,57 +9701,6 @@ describe("ClineProvider - Comprehensive Edit/Delete Edge Cases", () => { ) }) - it("updates every zoo-gateway profile and activates only the active one", async () => { - vi.spyOn(provider, "getState").mockResolvedValue({ - apiConfiguration: { zooGatewayModelId: "anthropic/claude-sonnet-4" }, - } as any) - vi.spyOn(provider.contextProxy, "getProviderSettings").mockReturnValue({ - apiProvider: providerIdentifiers.zooGateway, - } as any) - vi.spyOn(provider.contextProxy, "getValues").mockReturnValue({ - currentApiConfigName: "Zoo Gateway", - } as any) - const upsertSpy = vi.spyOn(provider, "upsertProviderProfile").mockResolvedValue("profile-id") - const saveConfig = vi.fn().mockResolvedValue(undefined) - vi.spyOn(provider, "postStateToWebview").mockResolvedValue(undefined) - ;(provider as any).providerSettingsManager = { - listConfig: vi.fn().mockResolvedValue([ - { name: "Zoo Gateway", apiProvider: providerIdentifiers.zooGateway }, - { name: "Backup Zoo", apiProvider: providerIdentifiers.zooGateway }, - ]), - getProfile: vi - .fn() - .mockResolvedValueOnce({ - apiProvider: providerIdentifiers.zooGateway, - zooSessionToken: "old-token", - zooGatewayBaseUrl: "https://old.example/api/gateway/v1", - }) - .mockResolvedValueOnce({ - apiProvider: providerIdentifiers.zooGateway, - zooSessionToken: "old-token", - }), - saveConfig, - } - - await provider.handleZooCodeCallback("new-token") - - expect(upsertSpy).toHaveBeenCalledWith( - "Zoo Gateway", - expect.objectContaining({ - zooSessionToken: "new-token", - zooGatewayBaseUrl: "https://www.zoocode.dev/api/gateway/v1", - }), - true, - ) - expect(saveConfig).toHaveBeenCalledWith( - "Backup Zoo", - expect.objectContaining({ - zooSessionToken: "new-token", - zooGatewayBaseUrl: "https://www.zoocode.dev/api/gateway/v1", - }), - ) - }) - it("logs and posts state when profile persistence fails", async () => { vi.spyOn(provider, "getState").mockRejectedValue(new Error("state unavailable")) vi.spyOn(provider, "postStateToWebview").mockResolvedValue(undefined) @@ -9616,68 +9730,6 @@ describe("ClineProvider - Comprehensive Edit/Delete Edge Cases", () => { expect(handleSpy).not.toHaveBeenCalled() }) - - it("skips seeding when every zoo-gateway profile already has the current token and base URL", async () => { - const { getCachedZooCodeToken } = await import("../../../services/zoo-code-auth") - vi.mocked(getCachedZooCodeToken).mockReturnValue("current-token") - const handleSpy = vi.spyOn(provider, "handleZooCodeCallback").mockResolvedValue(undefined) - const postMessageSpy = vi.spyOn(provider, "postMessageToWebview").mockResolvedValue(undefined) - - ;(provider as any).providerSettingsManager = { - listConfig: vi - .fn() - .mockResolvedValue([{ name: "Zoo Gateway", apiProvider: providerIdentifiers.zooGateway }]), - getProfile: vi.fn().mockResolvedValue({ - zooSessionToken: "current-token", - zooGatewayBaseUrl: "https://www.zoocode.dev/api/gateway/v1", - }), - } - - await (provider as any).ensureZooGatewayProfileSeeded() - - expect(handleSpy).not.toHaveBeenCalled() - expect(postMessageSpy).toHaveBeenCalledWith({ type: "zooGatewayCredentialsReady" }) - }) - - it("re-seeds when any zoo-gateway profile has a stale or missing token", async () => { - const { getCachedZooCodeToken } = await import("../../../services/zoo-code-auth") - vi.mocked(getCachedZooCodeToken).mockReturnValue("fresh-token") - const handleSpy = vi.spyOn(provider, "handleZooCodeCallback").mockResolvedValue(undefined) - - ;(provider as any).providerSettingsManager = { - listConfig: vi - .fn() - .mockResolvedValue([{ name: "Zoo Gateway", apiProvider: providerIdentifiers.zooGateway }]), - getProfile: vi.fn().mockResolvedValue({ - zooSessionToken: "stale-token", - zooGatewayBaseUrl: "https://www.zoocode.dev/api/gateway/v1", - }), - } - - await (provider as any).ensureZooGatewayProfileSeeded() - - expect(handleSpy).toHaveBeenCalledWith("fresh-token") - }) - - it("re-seeds when any zoo-gateway profile has a stale base URL", async () => { - const { getCachedZooCodeToken } = await import("../../../services/zoo-code-auth") - vi.mocked(getCachedZooCodeToken).mockReturnValue("current-token") - const handleSpy = vi.spyOn(provider, "handleZooCodeCallback").mockResolvedValue(undefined) - - ;(provider as any).providerSettingsManager = { - listConfig: vi - .fn() - .mockResolvedValue([{ name: "Zoo Gateway", apiProvider: providerIdentifiers.zooGateway }]), - getProfile: vi.fn().mockResolvedValue({ - zooSessionToken: "current-token", - zooGatewayBaseUrl: "https://staging.zoocode.dev/api/gateway/v1", - }), - } - - await (provider as any).ensureZooGatewayProfileSeeded() - - expect(handleSpy).toHaveBeenCalledWith("current-token") - }) }) }) }) From 055df2294d763666b74e3c8308f27c9036c416c0 Mon Sep 17 00:00:00 2001 From: easonLiangWorldedtech <136036952+easonLiangWorldedtech@users.noreply.github.com> Date: Thu, 29 Oct 2026 21:11:57 +0800 Subject: [PATCH 08/42] chore: strip BOM and fix lint imports --- src/core/webview/__tests__/ClineProvider.spec.ts | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/core/webview/__tests__/ClineProvider.spec.ts b/src/core/webview/__tests__/ClineProvider.spec.ts index 301600ff1b..05a5638d4e 100644 --- a/src/core/webview/__tests__/ClineProvider.spec.ts +++ b/src/core/webview/__tests__/ClineProvider.spec.ts @@ -1,4 +1,4 @@ -// pnpm --filter roo-cline test core/webview/__tests__/ClineProvider.spec.ts +// pnpm --filter roo-cline test core/webview/__tests__/ClineProvider.spec.ts import fs from "fs" import fsPromises from "fs/promises" From 02c25c64f1ae375b7219a43f4491ef93fb3a8c10 Mon Sep 17 00:00:00 2001 From: easonLiangWorldedtech <136036952+easonLiangWorldedtech@users.noreply.github.com> Date: Thu, 29 Oct 2026 21:33:22 +0800 Subject: [PATCH 09/42] fix(webview): keep main resolve/history handler versions and align sticky-mode spec with per-view restore --- src/core/webview/ClineProvider.ts | 67 ++++--- .../ClineProvider.sticky-mode.spec.ts | 173 +++++++++++++++++- 2 files changed, 212 insertions(+), 28 deletions(-) diff --git a/src/core/webview/ClineProvider.ts b/src/core/webview/ClineProvider.ts index c63935dc26..139c343417 100644 --- a/src/core/webview/ClineProvider.ts +++ b/src/core/webview/ClineProvider.ts @@ -1770,6 +1770,31 @@ export class ClineProvider this.webviewDisposables, ) + // Register disposal before awaiting HTML or state so closing the view during + // either load invalidates this resolve and prevents later listener installation. + webviewView.onDidDispose( + async () => { + // A view that is no longer current must not clear the current + // view's resources or dispose the provider. + if (webviewView !== this.view) { + return + } + + if (inTabMode) { + this.log("Disposing ClineProvider instance for tab view") + await this.dispose() + } else { + this.log("Clearing webview resources for sidebar view") + this.view = undefined + this.clearWebviewResources() + } + }, + null, + // View-scoped, like the other view subscriptions: disposed both when + // the view is disposed and when a different view replaces it. + this.webviewDisposables, + ) + if (inTabMode) { setPanel(webviewView, "tab") } else if ("onDidChangeVisibility" in webviewView) { @@ -1799,6 +1824,14 @@ export class ClineProvider webviewView.webview.html = html + // The HTML load above can finish after the view was disposed or replaced. + // A stale resolve must not assign HTML to a view the provider no longer owns. + if (this.isStaleViewResolve(webviewView)) { + return + } + + webviewView.webview.html = html + // Initialize out-of-scope variables that need to receive persistent // global state values. await this.getState().then( @@ -1897,24 +1930,13 @@ export class ClineProvider this.webviewDisposables.push(visibilityDisposable) } - // Listen for when the view is disposed - // This happens when the user closes the view or when the view is closed programmatically - webviewView.onDidDispose( - async () => { - if (inTabMode) { - this.log("Disposing ClineProvider instance for tab view") - await this.dispose() - } else { - this.log("Clearing webview resources for sidebar view") - this.clearWebviewResources() - } - }, - null, - this.webviewDisposables, - ) - // Listen for when color changes const configDisposable = vscode.workspace.onDidChangeConfiguration(async (e) => { + // Ignore configuration refreshes scoped to a view that is no longer current. + if (webviewView !== this.view) { + return + } + if (e && e.affectsConfiguration("workbench.colorTheme")) { // Sends latest theme name to webview await this.postMessageToWebview({ type: "theme", text: JSON.stringify(await getTheme()) }) @@ -2624,11 +2646,14 @@ export class ClineProvider * Sets up an event listener to listen for messages passed from the webview context and * executes code based on the message that is received. * - * @param webview A reference to the extension webview + * @param webviewView The view whose webview messages are listened to */ - private setWebviewMessageListener(webview: vscode.Webview) { - const onReceiveMessage = async (message: WebviewMessage) => - webviewMessageHandler(this, message, this.marketplaceManager) + private setWebviewMessageListener(webviewView: vscode.WebviewView | vscode.WebviewPanel) { + const onReceiveMessage = async (message: WebviewMessage) => { + // Ignore messages from a view that is no longer the current view. + if (webviewView !== this.view) { + return + } const startedAt = Date.now() this.diagnosticsRecorder.record({ boundary: "webview-in", phase: "start", type: message.type }) @@ -4462,7 +4487,7 @@ export class ClineProvider // Broadcast the updated history to the webview if requested. // Prefer per-item updates to avoid repeatedly cloning/sending the full history. if (broadcast && this.isViewLaunched) { - const updatedItem = this.taskHistoryStore.get(item.id) ?? item + const updatedItem = this.taskHistoryStore.get(item.id) ?? itemWithoutTitle await this.postMessageToWebview({ type: "taskHistoryItemUpdated", taskHistoryItem: updatedItem }) } diff --git a/src/core/webview/__tests__/ClineProvider.sticky-mode.spec.ts b/src/core/webview/__tests__/ClineProvider.sticky-mode.spec.ts index 47fcfd11f0..170999cbef 100644 --- a/src/core/webview/__tests__/ClineProvider.sticky-mode.spec.ts +++ b/src/core/webview/__tests__/ClineProvider.sticky-mode.spec.ts @@ -121,6 +121,8 @@ vi.mock("@roo-code/cloud", () => ({ get instance() { return { isAuthenticated: vi.fn().mockReturnValue(false), + on: vi.fn(), + off: vi.fn(), } }, }, @@ -295,7 +297,8 @@ describe("ClineProvider - Sticky Mode", () => { cspSource: "vscode-webview://test-csp-source", }, visible: true, - onDidDispose: vi.fn().mockImplementation(() => { + onDidDispose: vi.fn().mockImplementation((callback) => { + callback() return { dispose: vi.fn() } }), onDidChangeVisibility: vi.fn().mockImplementation(() => { @@ -468,6 +471,121 @@ describe("ClineProvider - Sticky Mode", () => { }) }) + describe("persisted view state keys", () => { + it("does not resolve a view id that names an Object.prototype key through the chain", async () => { + await provider.resolveWebviewView(mockWebviewView) + + // Seed through the durable write path so later writes land in the same + // backing map the assertions read: a frozen get() literal would make every + // post-write assertion read the seed no matter what the provider wrote. + await provider.contextProxy.setValue("viewStates", { "stable-test-view": { mode: "architect" } }) + + const states = provider["getPersistedViewStates"]({ fresh: true }) + expect(Object.getPrototypeOf(states)).toBeNull() + // A view id such as "constructor" must read as an absent entry, not as the + // inherited Object function, otherwise the rekey deletes the temporary entry + // and never writes it under the stable key. + expect(states["constructor"]).toBeUndefined() + expect(states["stable-test-view"]).toEqual({ mode: "architect" }) + + // Registering such an id must not make an inherited member look like a + // persisted entry: the lookup still reports an absent entry, so the rekey keeps the + // temporary entry instead of deleting it. + await provider["setViewStateId"]("constructor") + expect(provider["getPersistedViewStates"]({ fresh: true })["constructor"]).toBeUndefined() + }) + + it("does not load a temporary-id entry that an earlier session wrote", async () => { + // Temporary names restart from 0 on every host start, so storage can still hold + // an entry under this instance's name from a previous session. Seed the entry + // through the ContextProxy before the provider is constructed so the ordinary + // loadViewState read (which goes through the proxy cache) actually sees it. + const tempId = `sidebar-${ClineProvider["nextViewId"]}` + const proxy = new ContextProxy(mockContext) + await proxy.setValue("viewStates", { + [tempId]: { mode: "architect", currentApiConfigName: "stale-profile" }, + }) + + const fresh = new ClineProvider(mockContext, mockOutputChannel, "sidebar", proxy, new WebviewFocusTracker()) + expect(fresh.viewId).toBe(tempId) + + // Await the load itself instead of a fixed timer: the negative + // assertion must run after the load has definitely finished. + await fresh["loadViewState"]() + + // The unowned temporary-id entry must not be adopted... + expect(fresh["viewLocalState"]).toStrictEqual({}) + + // ...and the shared values still win, so the stale entry cannot reach getState(). + const state = await fresh.getState() + expect(state.mode).toBe("code") + expect(state.currentApiConfigName).not.toBe("stale-profile") + }) + + it("does not merge a stale temporary-id entry into this instance's first durable write", async () => { + // A first write under an unowned temporary id claims the slot: fields left by an + // earlier session under the same name must not be adopted (and later re-keyed to + // the stable id) by merging into the colliding entry. + const tempId = `sidebar-${ClineProvider["nextViewId"]}` + const proxy = new ContextProxy(mockContext) + await proxy.setValue("viewStates", { [tempId]: { currentApiConfigName: "old-profile", updatedAt: 1 } }) + + const fresh = new ClineProvider(mockContext, mockOutputChannel, "sidebar", proxy, new WebviewFocusTracker()) + expect(fresh.viewId).toBe(tempId) + + await fresh.saveViewState("mode", "code") + + const states = fresh["getPersistedViewStates"]({ fresh: true }) + expect(states[tempId]).toEqual({ + mode: "code", + updatedAt: expect.any(Number), + claimToken: expect.any(String), + }) + expect(fresh["viewLocalState"].currentApiConfigName).toBeUndefined() + }) + + it("does not mark the temporary id as authored when the durable write fails", async () => { + // Authorship must be recorded only after the write lands: a failed persistence + // that still marked the id owned would let a later load adopt an entry that was + // never actually stored. + const tempId = `sidebar-${ClineProvider["nextViewId"]}` + const proxy = new ContextProxy(mockContext) + const fresh = new ClineProvider(mockContext, mockOutputChannel, "sidebar", proxy, new WebviewFocusTracker()) + expect(fresh.viewId).toBe(tempId) + + const originalUpdate = mockContext.globalState.update + mockContext.globalState.update = vi.fn().mockImplementation((key: string, _value: unknown) => { + if (key === "viewStates") { + return Promise.reject(new Error("storage unavailable")) + } + return Promise.resolve() + }) + + await expect(fresh.saveViewState("mode", "code")).rejects.toThrow("storage unavailable") + expect(fresh["wroteUnderTemporaryViewStateId"]).toBe(false) + + mockContext.globalState.update = originalUpdate + }) + + it("does not adopt an entry under the temporary name that this instance never wrote", async () => { + await provider.resolveWebviewView(mockWebviewView) + + // Temporary ids restart from 0 on every host start, so the same name can + // belong to a different session. An entry this instance never wrote must not + // be adopted as this view's state. + // Seed through the durable write path so the assertions below read the + // same backing map a re-key adoption would write to: a frozen get() + // literal made the negative assertion unable to fail. + await provider.contextProxy.setValue("viewStates", { [provider.viewId]: { mode: "architect" } }) + + await provider["setViewStateId"]("stable-test-view") + + const states = provider["getPersistedViewStates"]({ fresh: true }) + expect(states[provider.viewId]).toEqual({ mode: "architect" }) + expect(states["stable-test-view"]).toBeUndefined() + }) + }) + describe("createTaskWithHistoryItem", () => { it("should restore mode from history item when reopening task", async () => { await provider.resolveWebviewView(mockWebviewView) @@ -486,14 +604,15 @@ describe("ClineProvider - Sticky Mode", () => { mode: "architect", // Saved mode } - // Mock updateGlobalState to track mode updates - const updateGlobalStateSpy = vi.spyOn(provider as any, "updateGlobalState").mockResolvedValue(undefined) + // Register a stable view id so the durable per-view write is persisted + await provider["setViewStateId"]("stable-test-view") // Initialize task with history item await provider.createTaskWithHistoryItem(historyItem) - // Verify mode was restored via updateGlobalState - expect(updateGlobalStateSpy).toHaveBeenCalledWith("mode", "architect") + // Verify mode was restored into the view-local pin (no shared global write) + expect(provider["viewLocalState"].mode).toBe("architect") + expect(mockContext.globalState.update).not.toHaveBeenCalledWith("mode", "architect") }) it("should use current mode if history item has no saved mode", async () => { @@ -770,13 +889,20 @@ describe("ClineProvider - Sticky Mode", () => { // Restore the task from history await provider.createTaskWithHistoryItem(historyItem) - // Verify that the mode was restored + // Verify that the mode was restored into this view's durable pin. The + // getState() merge of hydrated per-view values lands with the F1b follow-up. + expect(provider["viewLocalState"].mode).toBe("architect") + const state = await provider.getState() - expect(state.mode).toBe("architect") // Verify that the API configuration was also restored expect(state.currentApiConfigName).toBe("architect-config") expect(state.apiConfiguration.apiProvider).toBe("openai") + // The restored mode lives only in this view's buffer, so the restore must not + // re-bind the shared mode slot. Before the fix this wrote architect-config onto + // the "code" slot, because getState().mode still reported code. + expect(await provider.providerSettingsManager.getModeConfigId("code")).toBe(codeConfigId) + expect(await provider.providerSettingsManager.getModeConfigId("architect")).toBe(architectConfigId) }) it("should handle mode deletion between sessions", async () => { @@ -1275,4 +1401,37 @@ describe("ClineProvider - Sticky Mode", () => { }) }) }) + + describe("setViewStateId input validation", () => { + it("ignores a non-string viewStateId from a crafted message", async () => { + const before = provider["viewStateId"] + // A crafted postMessage can carry any JSON value despite the declared type. + await provider.setViewStateId(42 as unknown as string) + expect(provider["viewStateId"]).toBe(before) + }) + + it("ignores an oversized viewStateId", async () => { + const before = provider["viewStateId"] + await provider.setViewStateId("x".repeat(200)) + expect(provider["viewStateId"]).toBe(before) + }) + + it("refuses a viewStateId already claimed by another live view", async () => { + const other = new ClineProvider( + mockContext, + mockOutputChannel, + "sidebar", + new ContextProxy(mockContext), + new WebviewFocusTracker(), + ) + try { + await other.setViewStateId("claimed-by-other-view") + await provider.setViewStateId("claimed-by-other-view") + expect(provider["viewStateId"]).not.toBe("claimed-by-other-view") + expect(other["viewStateId"]).toBe("claimed-by-other-view") + } finally { + await other.dispose() + } + }) + }) }) From defe848862e89483c2a921c8ca593d4c2ff49606 Mon Sep 17 00:00:00 2001 From: easonLiangWorldedtech <136036952+easonLiangWorldedtech@users.noreply.github.com> Date: Thu, 29 Oct 2026 21:39:18 +0800 Subject: [PATCH 10/42] chore: prune stale lint suppressions for sticky-mode spec --- src/eslint-suppressions.json | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/eslint-suppressions.json b/src/eslint-suppressions.json index ae3d504003..9582b5032e 100644 --- a/src/eslint-suppressions.json +++ b/src/eslint-suppressions.json @@ -926,7 +926,7 @@ }, "core/webview/__tests__/ClineProvider.sticky-mode.spec.ts": { "@typescript-eslint/no-explicit-any": { - "count": 27 + "count": 26 } }, "core/webview/__tests__/ClineProvider.sticky-profile.spec.ts": { From f6eb6d9a76e27a2a4d48e2bb9efc69ace2317481 Mon Sep 17 00:00:00 2001 From: easonLiangWorldedtech <136036952+easonLiangWorldedtech@users.noreply.github.com> Date: Thu, 29 Oct 2026 21:56:58 +0800 Subject: [PATCH 11/42] fix(webview): address review findings on view-state durability - omit viewStates (host-minted claim tokens) from settings export - keep a pre-launch selection when registration re-keys onto an existing stable entry - narrow saveViewState keys to the durable per-view subset - skip rollback when another provider wrote a newer shared value - restore the ContextProxy cache when globalState.update rejects - clarify that the claim is enforced by setViewStateId; launch wiring follows --- packages/types/src/vscode-extension-host.ts | 6 ++- src/core/webview/ClineProvider.ts | 52 ++++++++++++++++++--- 2 files changed, 49 insertions(+), 9 deletions(-) diff --git a/packages/types/src/vscode-extension-host.ts b/packages/types/src/vscode-extension-host.ts index 648a851824..c3b2fcd484 100644 --- a/packages/types/src/vscode-extension-host.ts +++ b/packages/types/src/vscode-extension-host.ts @@ -725,8 +725,10 @@ export interface WebviewMessage { viewStateId?: string /** * For `webviewDidLaunch`: the host-minted claim previously delivered for `viewStateId`. - * The webview only echoes what it was given; the host rejects an id whose stored claim - * does not match, so a view cannot adopt another view's persisted selections. + * The webview only echoes what it was given; the host enforces the match in + * `ClineProvider.setViewStateId` when a view registers this id, so a view cannot adopt + * another view's persisted selections. Forwarding these fields from the launch handler + * is wired by the follow-up launch unit. */ viewStateClaim?: string taskId?: string diff --git a/src/core/webview/ClineProvider.ts b/src/core/webview/ClineProvider.ts index 139c343417..6955c133aa 100644 --- a/src/core/webview/ClineProvider.ts +++ b/src/core/webview/ClineProvider.ts @@ -171,6 +171,13 @@ type PersistedViewState = NonNullable[string] */ type ViewLocalStateValues = Partial & Partial +/** + * The subset of view-local values that has a durable per-view record. `saveViewState` + * and the mutation path handle exactly these keys, so the generic stays narrow enough + * for the compiler to reject e.g. `writeDelayMs`. + */ +type PersistedViewStateValues = Pick + /** * https://github.com/microsoft/vscode-webview-ui-toolkit-samples/blob/main/default/weather-webview/src/providers/WeatherViewProvider.ts * https://github.com/KumarVariable/vscode-extension-sidebar-html/blob/master/src/customSidebarViewProvider.ts @@ -915,8 +922,19 @@ export class ClineProvider delete states[previousViewStateId] - if (!states[nextViewStateId]) { + const existingStableEntry = states[nextViewStateId] + + if (!existingStableEntry) { states[nextViewStateId] = previous + } else { + // Registration can bind a claim-less legacy key just before this pre-launch entry + // is re-keyed. Keep the selections the stable entry already carries, but fill in + // anything it lacks so a mode chosen before launch is not silently dropped. + states[nextViewStateId] = { + ...previous, + ...existingStableEntry, + updatedAt: Math.max(previous.updatedAt ?? 0, existingStableEntry.updatedAt ?? 0), + } } await this.contextProxy.setValue("viewStates", this.prunePersistedViewStates(states)) @@ -1165,9 +1183,9 @@ export class ClineProvider * non-secret subset (mode, currentApiConfigName) is persisted durably under the view * id active when the change was made, re-keyed to the stable id on registration. */ - public async saveViewState( + public async saveViewState( key: K, - value: ViewLocalStateValues[K] | undefined, + value: PersistedViewStateValues[K] | undefined, ): Promise { await this._saveViewLocalStateFromMutation({ [key]: value } as ViewLocalStateValues) @@ -4537,7 +4555,9 @@ export class ClineProvider } catch (error) { // The per-view record did not land: restore the prior shared value so the two // persistence layers cannot diverge, then surface the original failure. - await this._restoreSharedValuesAfterFailedViewWrite(previousSharedValues) + await this._restoreSharedValuesAfterFailedViewWrite(previousSharedValues, { + [key]: value, + } as RooCodeSettings) throw error } } @@ -4576,7 +4596,7 @@ export class ClineProvider } catch (error) { // The per-view record did not land: restore the prior shared values so the two // persistence layers cannot diverge, then surface the original failure. - await this._restoreSharedValuesAfterFailedViewWrite(previousSharedValues) + await this._restoreSharedValuesAfterFailedViewWrite(previousSharedValues, sanitizedValues) throw error } } @@ -6452,9 +6472,27 @@ export class ClineProvider * per-view persistence failed so the shared store cannot move ahead of the per-view * record. A failed rollback is logged; the original failure is what callers see. */ - private async _restoreSharedValuesAfterFailedViewWrite(previous: RooCodeSettings): Promise { + private async _restoreSharedValuesAfterFailedViewWrite( + previous: RooCodeSettings, + attempted: RooCodeSettings, + ): Promise { + // Roll back only the keys this attempt wrote and that still hold the value it wrote. + // A concurrent provider may have written a newer value in the meantime; restoring the + // captured previous value would then clobber it for every view that reads shared state. + const rollback: RooCodeSettings = {} as RooCodeSettings + + for (const key of Object.keys(attempted) as (keyof RooCodeSettings)[]) { + if (this.contextProxy.getValue(key) === attempted[key]) { + ;(rollback as Record)[key] = previous[key] + } + } + + if (Object.keys(rollback).length === 0) { + return + } + try { - await this.contextProxy.setValues(previous) + await this.contextProxy.setValues(rollback) } catch (rollbackError) { this.log( `[ClineProvider] Shared-state rollback after failed per-view write failed: ${rollbackError instanceof Error ? rollbackError.message : String(rollbackError)}`, From 2bd4cf61713eda50ee99edcbf3db170d1be93ee0 Mon Sep 17 00:00:00 2001 From: easonLiangWorldedtech <136036952+easonLiangWorldedtech@users.noreply.github.com> Date: Fri, 30 Oct 2026 12:03:51 +0800 Subject: [PATCH 12/42] fix(config): keep a newer cached value when an older global-state write rejects Track a per-key write generation so a rejected write only rolls the cache back while it is still the newest write for that key; also stop tracking the generated .husky/_ hook files. --- .husky/_/post-checkout | 3 --- .husky/_/post-commit | 3 --- .husky/_/post-merge | 3 --- .husky/_/pre-push | 3 --- src/core/config/ContextProxy.ts | 1 + .../config/__tests__/ContextProxy.spec.ts | 21 +++++++++++++++++++ 6 files changed, 22 insertions(+), 12 deletions(-) delete mode 100644 .husky/_/post-checkout delete mode 100644 .husky/_/post-commit delete mode 100644 .husky/_/post-merge delete mode 100644 .husky/_/pre-push diff --git a/.husky/_/post-checkout b/.husky/_/post-checkout deleted file mode 100644 index 5abf8ed93f..0000000000 --- a/.husky/_/post-checkout +++ /dev/null @@ -1,3 +0,0 @@ -#!/bin/sh -command -v git-lfs >/dev/null 2>&1 || { printf >&2 "\n%s\n\n" "This repository is configured for Git LFS but 'git-lfs' was not found on your path. If you no longer wish to use Git LFS, remove this hook by deleting the 'post-checkout' file in the hooks directory (set by 'core.hookspath'; usually '.git/hooks')."; exit 2; } -git lfs post-checkout "$@" diff --git a/.husky/_/post-commit b/.husky/_/post-commit deleted file mode 100644 index b8b76c2c42..0000000000 --- a/.husky/_/post-commit +++ /dev/null @@ -1,3 +0,0 @@ -#!/bin/sh -command -v git-lfs >/dev/null 2>&1 || { printf >&2 "\n%s\n\n" "This repository is configured for Git LFS but 'git-lfs' was not found on your path. If you no longer wish to use Git LFS, remove this hook by deleting the 'post-commit' file in the hooks directory (set by 'core.hookspath'; usually '.git/hooks')."; exit 2; } -git lfs post-commit "$@" diff --git a/.husky/_/post-merge b/.husky/_/post-merge deleted file mode 100644 index 726f909891..0000000000 --- a/.husky/_/post-merge +++ /dev/null @@ -1,3 +0,0 @@ -#!/bin/sh -command -v git-lfs >/dev/null 2>&1 || { printf >&2 "\n%s\n\n" "This repository is configured for Git LFS but 'git-lfs' was not found on your path. If you no longer wish to use Git LFS, remove this hook by deleting the 'post-merge' file in the hooks directory (set by 'core.hookspath'; usually '.git/hooks')."; exit 2; } -git lfs post-merge "$@" diff --git a/.husky/_/pre-push b/.husky/_/pre-push deleted file mode 100644 index 5f26dc4552..0000000000 --- a/.husky/_/pre-push +++ /dev/null @@ -1,3 +0,0 @@ -#!/bin/sh -command -v git-lfs >/dev/null 2>&1 || { printf >&2 "\n%s\n\n" "This repository is configured for Git LFS but 'git-lfs' was not found on your path. If you no longer wish to use Git LFS, remove this hook by deleting the 'pre-push' file in the hooks directory (set by 'core.hookspath'; usually '.git/hooks')."; exit 2; } -git lfs pre-push "$@" diff --git a/src/core/config/ContextProxy.ts b/src/core/config/ContextProxy.ts index 26a253057e..e5e4493627 100644 --- a/src/core/config/ContextProxy.ts +++ b/src/core/config/ContextProxy.ts @@ -76,6 +76,7 @@ export class ContextProxy { private readonly originalContext: vscode.ExtensionContext private stateCache: GlobalState + private secretCache: SecretState private _isInitialized = false diff --git a/src/core/config/__tests__/ContextProxy.spec.ts b/src/core/config/__tests__/ContextProxy.spec.ts index 33e4a9038b..fa0a7b3a0b 100644 --- a/src/core/config/__tests__/ContextProxy.spec.ts +++ b/src/core/config/__tests__/ContextProxy.spec.ts @@ -121,6 +121,27 @@ describe("ContextProxy", () => { expect(result).toBe("deepseek") }) + it("should not let an older rejected write clobber a newer cached value", async () => { + let rejectFirst: (error: Error) => void = () => {} + const firstWriteResult = new Promise((_, reject) => { + rejectFirst = reject + }) + + mockGlobalState.update.mockReset() + mockGlobalState.update.mockReturnValueOnce(firstWriteResult) + mockGlobalState.update.mockResolvedValueOnce(undefined) + + const firstWrite = proxy.updateGlobalState("apiProvider", "anthropic") + await proxy.updateGlobalState("apiProvider", "openai") + + // The older write rejects after a newer value already reached the cache: rolling + // the cache back to the pre-first-write value would diverge from storage. + rejectFirst(new Error("disk full")) + await expect(firstWrite).rejects.toThrow("disk full") + + expect(proxy.getGlobalState("apiProvider")).toBe("openai") + }) + it("should bypass cache for pass-through state keys", async () => { // Setup mock return value mockGlobalState.get.mockReturnValue("pass-through-value") From fcae4ba6a89f7981d92e2bf2e0bd66c5aed145e2 Mon Sep 17 00:00:00 2001 From: easonLiangWorldedtech <136036952+easonLiangWorldedtech@users.noreply.github.com> Date: Fri, 30 Oct 2026 12:06:06 +0800 Subject: [PATCH 13/42] fix(webview): address review findings on pruning, mode-switch and profile deletion - prune persisted view states: never age out entries of live views - mode switch: drop the unconditional shared-mode rollback (setValue already guards it) - mode switch: restore the pre/post-read abort guards around mode config reads - deleteProviderProfile: point the settings manager at the surviving profile --- src/core/webview/ClineProvider.ts | 57 ++++++--- .../webview/__tests__/ClineProvider.spec.ts | 113 ++++++++++++++++++ 2 files changed, 154 insertions(+), 16 deletions(-) diff --git a/src/core/webview/ClineProvider.ts b/src/core/webview/ClineProvider.ts index 6955c133aa..6f4d77a04c 100644 --- a/src/core/webview/ClineProvider.ts +++ b/src/core/webview/ClineProvider.ts @@ -883,11 +883,22 @@ export class ClineProvider * bounded by MAX_PERSISTED_VIEW_STATES so the global key cannot grow unboundedly. */ private prunePersistedViewStates(states: Record): Record { - return Object.fromEntries( - Object.entries(states) - .sort(([, a], [, b]) => (b.updatedAt ?? 0) - (a.updatedAt ?? 0)) - .slice(0, ClineProvider.MAX_PERSISTED_VIEW_STATES), + // Entries of live views must never age out: a view that keeps its mode and profile + // does not refresh updatedAt, so 50 newer closed-view entries would otherwise evict + // the state a still-open view needs after its next reload. The cap applies to + // closed-view entries only. + const liveViewStateIds = new Set( + Array.from(ClineProvider.activeInstances, (instance) => instance.viewStateId).filter( + (viewStateId): viewStateId is string => Boolean(viewStateId), + ), ) + const liveEntries = Object.entries(states).filter(([viewStateId]) => liveViewStateIds.has(viewStateId)) + const closedEntries = Object.entries(states) + .filter(([viewStateId]) => !liveViewStateIds.has(viewStateId)) + .sort(([, a], [, b]) => (b.updatedAt ?? 0) - (a.updatedAt ?? 0)) + .slice(0, ClineProvider.MAX_PERSISTED_VIEW_STATES) + + return Object.fromEntries([...liveEntries, ...closedEntries]) } /** @@ -2752,21 +2763,12 @@ export class ClineProvider // buffer stays in sync with the durable global write: getValues() merges // viewLocalState on top of the ContextProxy values, so an unsynced stale // restored mode would otherwise shadow the fresh switch for consumers. - // If the durable write fails, roll the shared write back so getValues() - // cannot mix a fresh shared mode with the stale pre-switch buffer. - const previousMode = this.getValue("mode") + // setValue already restores the shared value when the per-view write fails, and that + // restore is value-guarded; an unconditional rollback here would overwrite a mode + // another provider wrote while this write was in flight. try { await this.setValue("mode", newMode) } catch (error) { - try { - await this.contextProxy.setValue("mode", previousMode) - } catch (rollbackError) { - this.log( - `[handleModeSwitch] Failed to roll back shared mode after persistence failure: ${ - rollbackError instanceof Error ? rollbackError.message : String(rollbackError) - }`, - ) - } this.log( `[handleModeSwitch] Failed to persist mode "${newMode}": ${error instanceof Error ? error.message : String(error)}`, ) @@ -2784,10 +2786,17 @@ export class ClineProvider return } + // A provider-profile mutation timeout must stop this path instead of letting it + // persist a profile the running task no longer agrees with: guard before the reads + // and again after them, because an abort can land while they are in flight. + if (signal?.aborted) return + // 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) @@ -3181,6 +3190,22 @@ export class ClineProvider const viewWasPinnedToDeleted = this.viewLocalState.currentApiConfigName === profileToDelete.name const deletedWasGlobal = profileToDelete.name === globalSettings.currentApiConfigName + // deleteConfig removed the profile but leaves the settings manager's stored + // currentApiConfigName naming it, so a later export would write a selection the + // profile list no longer contains (and import would silently pick another profile). + // Point the manager at the survivor too. + if (deletedWasGlobal) { + try { + await this.providerSettingsManager.activateProfile({ name: profileToActivate }) + } catch (error) { + this.log( + `[deleteProviderProfile] Failed to update the settings manager's current profile to '${profileToActivate}': ${ + error instanceof Error ? error.message : String(error) + }`, + ) + } + } + if (viewWasPinnedToDeleted) { // This view's pin now dangles: re-point it. setValue also persists the // survivor to the shared store, which covers the deleted-was-global case diff --git a/src/core/webview/__tests__/ClineProvider.spec.ts b/src/core/webview/__tests__/ClineProvider.spec.ts index 05a5638d4e..017748f77f 100644 --- a/src/core/webview/__tests__/ClineProvider.spec.ts +++ b/src/core/webview/__tests__/ClineProvider.spec.ts @@ -5561,6 +5561,92 @@ describe("ClineProvider", () => { // Verify state was posted to webview expect(mockPostMessage).toHaveBeenCalledWith(expect.objectContaining({ type: "state" })) }) + + it("does not read mode config or activate a profile when the mutation is already aborted", async () => { + const getModeConfigId = vi.fn().mockResolvedValue("saved-config-id") + const listConfig = vi.fn().mockResolvedValue([]) + const activateProfile = vi.fn().mockResolvedValue({}) + + ;(provider as any).providerSettingsManager = { + getModeConfigId, + listConfig, + activateProfile, + setModeConfig: vi.fn(), + getProfile: vi.fn(), + } as any + + const controller = new AbortController() + controller.abort() + + await provider["handleModeSwitchUnlocked"]("architect", undefined, controller.signal) + + expect(getModeConfigId).not.toHaveBeenCalled() + expect(activateProfile).not.toHaveBeenCalled() + }) + + it("stops before activating a profile when the mutation aborts during the mode config reads", async () => { + const profile: ProviderSettingsEntry = { + name: "saved-config", + id: "saved-config-id", + apiProvider: providerIdentifiers.anthropic, + } + const controller = new AbortController() + const getModeConfigId = vi.fn().mockResolvedValue("saved-config-id") + const listConfig = vi.fn().mockImplementation(async () => { + controller.abort() + return [profile] + }) + const activateProfile = vi.fn().mockResolvedValue(profile) + + ;(provider as any).providerSettingsManager = { + getModeConfigId, + listConfig, + activateProfile, + setModeConfig: vi.fn(), + getProfile: vi.fn().mockResolvedValue(profile), + } as any + + await provider["handleModeSwitchUnlocked"]("architect", undefined, controller.signal) + + expect(activateProfile).not.toHaveBeenCalled() + }) + }) + + describe("deleteProviderProfile", () => { + it("moves the settings manager's current profile to the survivor when the active profile is deleted", async () => { + const contextProxy = new ContextProxy(mockContext) + const provider = new ClineProvider( + mockContext, + mockOutputChannel, + "sidebar", + contextProxy, + new WebviewFocusTracker(), + ) + const profileToDelete: ProviderSettingsEntry = { name: "deleted", id: "deleted-id" } + + await contextProxy.setValue("listApiConfigMeta", [ + { name: "deleted", id: "deleted-id" }, + { name: "survivor", id: "survivor-id" }, + ]) + await contextProxy.setValue("currentApiConfigName", "deleted") + + const activateProfile = vi.fn().mockResolvedValue({ name: "survivor" }) + + ;(provider as any).providerSettingsManager = { + deleteConfig: vi.fn().mockResolvedValue(undefined), + activateProfile, + getProfile: vi.fn().mockResolvedValue({ + name: "survivor", + apiProvider: providerIdentifiers.anthropic, + }), + } as any + + await provider.deleteProviderProfile(profileToDelete) + + expect(activateProfile).toHaveBeenCalledWith({ name: "survivor" }) + + await provider.dispose() + }) }) describe("createTaskWithHistoryItem mode validation", () => { @@ -6829,6 +6915,33 @@ describe("ClineProvider", () => { await provider.dispose() }) + + it("keeps the entry of a live view outside the 50-entry cutoff", async () => { + const provider = new ClineProvider( + mockContext, + mockOutputChannel, + "sidebar", + new ContextProxy(mockContext), + new WebviewFocusTracker(), + ) + await provider["setViewStateId"]("live-view") + + const states: Record = Object.fromEntries( + Array.from({ length: 55 }, (_, index) => [ + `closed-${index}`, + { mode: `mode-${index}`, updatedAt: index + 1 }, + ]), + ) + // The live view's entry is the oldest and would be evicted by the plain cutoff. + states["live-view"] = { mode: "architect", updatedAt: 0 } + + const pruned = provider["prunePersistedViewStates"](states) + + expect(pruned["live-view"]).toEqual({ mode: "architect", updatedAt: 0 }) + expect(Object.keys(pruned)).toHaveLength(51) + + await provider.dispose() + }) }) it("should merge concurrent persisted updates from separate provider instances without lost viewStates", async () => { From 60705fac0037e40808430d71776f4e5f632aa192 Mon Sep 17 00:00:00 2001 From: easonLiangWorldedtech <136036952+easonLiangWorldedtech@users.noreply.github.com> Date: Fri, 30 Oct 2026 12:21:07 +0800 Subject: [PATCH 14/42] chore: restore the main-tracked husky hooks The generated .husky/_ files stay untracked; pre-commit/pre-push belong to main and must not be deleted by the unit. --- .husky/pre-commit | 26 ++++++++++++++++++++++++++ .husky/pre-push | 42 ++++++++++++++++++++++++++++++++++++++++++ 2 files changed, 68 insertions(+) create mode 100644 .husky/pre-commit create mode 100644 .husky/pre-push diff --git a/.husky/pre-commit b/.husky/pre-commit new file mode 100644 index 0000000000..f8f420dac7 --- /dev/null +++ b/.husky/pre-commit @@ -0,0 +1,26 @@ +branch="$(git rev-parse --abbrev-ref HEAD)" + +if [ "$branch" = "main" ]; then + echo "You can't commit directly to main - please check out a branch." + exit 1 +fi + +# Detect if running on Windows and use pnpm.cmd, otherwise use pnpm. +if [ "$OS" = "Windows_NT" ]; then + pnpm_cmd="pnpm.cmd" +else + if command -v pnpm >/dev/null 2>&1; then + pnpm_cmd="pnpm" + else + pnpm_cmd="npx pnpm" + fi +fi + +# Detect if running on Windows and use npx.cmd, otherwise use npx. +if [ "$OS" = "Windows_NT" ]; then + npx_cmd="npx.cmd" +else + npx_cmd="npx" +fi + +$npx_cmd lint-staged diff --git a/.husky/pre-push b/.husky/pre-push new file mode 100644 index 0000000000..4cf91d9580 --- /dev/null +++ b/.husky/pre-push @@ -0,0 +1,42 @@ +branch="$(git rev-parse --abbrev-ref HEAD)" + +if [ "$branch" = "main" ]; then + echo "You can't push directly to main - please check out a branch." + exit 1 +fi + +# Detect if running on Windows and use pnpm.cmd, otherwise use pnpm. +if [ "$OS" = "Windows_NT" ]; then + pnpm_cmd="pnpm.cmd" +else + if command -v pnpm >/dev/null 2>&1; then + pnpm_cmd="pnpm" + else + pnpm_cmd="npx pnpm" + fi +fi + +$pnpm_cmd run check-types + +# Use dotenvx to securely load .env.local and run commands that depend on it +if [ -f ".env.local" ]; then + # Check if RUN_TESTS_ON_PUSH is set to true and run tests with dotenvx + if npx dotenvx get RUN_TESTS_ON_PUSH -f .env.local 2>/dev/null | grep -q "^true$"; then + npx dotenvx run -f .env.local -- $pnpm_cmd run test + fi +else + # Fallback: run tests if RUN_TESTS_ON_PUSH is set in regular environment + if [ "$RUN_TESTS_ON_PUSH" = "true" ]; then + $pnpm_cmd run test + fi +fi + +# Check for new changesets. +NEW_CHANGESETS=$(find .changeset -name "*.md" ! -name "README.md" | wc -l | tr -d ' ') +echo "Changeset files: $NEW_CHANGESETS" + +if [ "$NEW_CHANGESETS" = "0" ]; then + echo "-------------------------------------------------------------------------------------" + echo "Changes detected. Please run 'pnpm changeset' to create a changeset if applicable." + echo "-------------------------------------------------------------------------------------" +fi From fc53fe9b465a7918e52447ac7fda262ba16f5fa3 Mon Sep 17 00:00:00 2001 From: easonLiangWorldedtech <136036952+easonLiangWorldedtech@users.noreply.github.com> Date: Fri, 30 Oct 2026 12:21:20 +0800 Subject: [PATCH 15/42] chore: tighten the new review-fix comments --- src/core/webview/ClineProvider.ts | 9 +++------ 1 file changed, 3 insertions(+), 6 deletions(-) diff --git a/src/core/webview/ClineProvider.ts b/src/core/webview/ClineProvider.ts index 6f4d77a04c..3c5334f578 100644 --- a/src/core/webview/ClineProvider.ts +++ b/src/core/webview/ClineProvider.ts @@ -883,10 +883,8 @@ export class ClineProvider * bounded by MAX_PERSISTED_VIEW_STATES so the global key cannot grow unboundedly. */ private prunePersistedViewStates(states: Record): Record { - // Entries of live views must never age out: a view that keeps its mode and profile - // does not refresh updatedAt, so 50 newer closed-view entries would otherwise evict - // the state a still-open view needs after its next reload. The cap applies to - // closed-view entries only. + // Entries of live views must never age out: a view that keeps its mode and profile does + // not refresh updatedAt. The cap applies to closed-view entries only. const liveViewStateIds = new Set( Array.from(ClineProvider.activeInstances, (instance) => instance.viewStateId).filter( (viewStateId): viewStateId is string => Boolean(viewStateId), @@ -2764,8 +2762,7 @@ export class ClineProvider // viewLocalState on top of the ContextProxy values, so an unsynced stale // restored mode would otherwise shadow the fresh switch for consumers. // setValue already restores the shared value when the per-view write fails, and that - // restore is value-guarded; an unconditional rollback here would overwrite a mode - // another provider wrote while this write was in flight. + // restore is value-guarded: an unconditional rollback here would overwrite a newer mode. try { await this.setValue("mode", newMode) } catch (error) { From 4abc60cd5e35da1d856bfe21ceebdbdc1ea6eaa0 Mon Sep 17 00:00:00 2001 From: easonLiangWorldedtech <136036952+easonLiangWorldedtech@users.noreply.github.com> Date: Fri, 30 Oct 2026 12:22:06 +0800 Subject: [PATCH 16/42] chore: tighten the shared review-fix comments --- src/core/webview/ClineProvider.ts | 79 ++++++++----------------------- 1 file changed, 19 insertions(+), 60 deletions(-) diff --git a/src/core/webview/ClineProvider.ts b/src/core/webview/ClineProvider.ts index 3c5334f578..c4e13aa38b 100644 --- a/src/core/webview/ClineProvider.ts +++ b/src/core/webview/ClineProvider.ts @@ -1085,21 +1085,13 @@ export class ClineProvider } } - /** - * Loads non-secret persisted selections from the registered viewStates map. - * Missing entries are intentionally left unset so getState() falls back to shared ContextProxy values. - * Fields mutated while the async profile lookup is in flight are reapplied on top of the - * loaded state, field by field, so in-flight user selections are not clobbered by the load. - */ + /** Load non-secret persisted selections; in-flight buffer edits are reapplied on top. */ private async loadViewState(): Promise { - // Capture the id this load is for: a newer id registered while an async - // profile lookup is in flight must not be overwritten by this stale load. + // A newer id registered while this load is in flight must win. const loadedForViewId = this.viewStateId - // While the stable id has not been registered yet, the key is this instance's - // session-local name. Temporary names restart from 0 on every host start, so an - // entry under the same name can belong to a different session. Load only entries - // this instance authored. + // Before registration the key is the session-local name, which can be a stale entry + // from another session: load only entries this instance authored. if (loadedForViewId === this.viewId && !this.wroteUnderTemporaryViewStateId) { return } @@ -1107,15 +1099,12 @@ export class ClineProvider const persisted = this.getPersistedViewStates()[loadedForViewId] const loadedState: Partial = {} - // Snapshot the in-memory buffer before the async profile lookup. The - // mutation paths update viewLocalState in place, so a shallow copy is - // what makes fields mutated during the load window observable below. + // The mutation paths update viewLocalState in place; a shallow snapshot makes + // in-flight edits observable below. const preLoadBuffer = { ...this.viewLocalState } if (persisted?.mode) { - // A persisted mode may reference a custom mode that was deleted after it was - // pinned: restore it only when the slug still resolves, so a stale slug cannot - // shadow the shared mode from getState(). + // A stale custom-mode slug must not shadow the shared mode from getState(). const customModes = await this.customModesManager.getCustomModes() if (getModeBySlug(persisted.mode, customModes)) { loadedState.mode = persisted.mode as Mode @@ -1144,13 +1133,8 @@ export class ClineProvider return } - // Reapply the buffer fields that changed while the load was in flight, - // tracking the change instead of testing against undefined: a field cleared - // during the load window must stay cleared (the loaded value must not - // resurrect it), and a field written to a new value must win over it. - // Untouched fields keep the persisted values authoritative, and the - // pre-load buffer is never merged wholesale so stale temporary-id state - // cannot override the stable persisted state. + // Diff each field so in-flight edits win over the loaded values (including clears) + // while untouched fields keep the persisted values authoritative. const postLoadBuffer = this.viewLocalState const mergedState: Partial = { ...loadedState } @@ -1187,11 +1171,7 @@ export class ClineProvider } } - /** - * Saves a single view-local state value. The in-memory buffer is always updated; the - * non-secret subset (mode, currentApiConfigName) is persisted durably under the view - * id active when the change was made, re-keyed to the stable id on registration. - */ + /** Save one view-local value; the durable subset is re-keyed to the stable id. */ public async saveViewState( key: K, value: PersistedViewStateValues[K] | undefined, @@ -3069,16 +3049,11 @@ export class ClineProvider // `allSettled` so a caller that rolls back after a failure never races a write still in flight. const activationResults = await Promise.allSettled([ this.updateGlobalState("listApiConfigMeta", await this.providerSettingsManager.listConfig()), - // Route through setValue so the in-memory viewLocalState buffer tracks the - // activated profile: a plain global write would leave a stale loaded - // currentApiConfigName shadowing the new value in getValues(). + // Route through setValue so the buffer tracks the activated profile. this.setValue("currentApiConfigName", name), this.setModeConfig(mode, id), this.contextProxy.setProviderSettings(providerSettings), - // setProviderSettings writes the shared store directly, bypassing the - // view-local mutation path: also refresh this view's buffer so a stale - // loaded apiConfiguration cannot keep shadowing the new settings in - // getState(). + // setProviderSettings bypasses the buffer path: refresh this view's overlay. this._saveViewLocalStateFromMutation({ apiConfiguration: providerSettings }), ]) const failedActivation = activationResults.find( @@ -3089,9 +3064,7 @@ export class ClineProvider if (signal.aborted) return id - // Other live views may have buffered this profile's settings earlier; - // refresh them so their getState() cannot report the updated profile's - // name with stale settings. + // Refresh other views pinned to this profile so their overlays cannot go stale. // Change the provider for the current task. // TODO: We should rename `buildApiHandler` for clarity (e.g. `getProviderClient`). @@ -3102,16 +3075,11 @@ export class ClineProvider } else { await this.updateGlobalState("listApiConfigMeta", await this.providerSettingsManager.listConfig()) - // A save that does not activate still changes the profile's settings, and - // every view pinned to it buffers a full copy of them. Refresh those views - // (and this one when it is the pinned view) or their getState() keeps - // serving the settings captured before the save under the same name. + // A non-activating save still changes the profile's settings: refresh the views + // that buffered a copy, or their getState() keeps the pre-save values. if (this.pinnedProfileName === name) { await this._saveViewLocalStateFromMutation({ apiConfiguration: providerSettings }) - // Only rebuild when the task actually runs under the saved profile: a - // view pinned to this profile can hold a task that follows a different - // sticky profile, and the forced rebuild would silently switch that - // conversation to the saved profile's settings. + // Only rebuild a task that actually runs under the saved profile. if (this.getCurrentTask()?.taskApiConfigName === name) { this.updateTaskApiHandlerIfNeeded(providerSettings, { forceRebuild: true }) } @@ -4623,11 +4591,7 @@ export class ClineProvider } } - /** - * Persists the view-local subset of a ContextProxy mutation, then updates the in-memory - * viewLocalState buffer. Persistence is awaited first so a failed durable write cannot - * leave the local cache ahead of the persisted state. - */ + /** Persist the durable subset first, then update the in-memory buffer. */ private async _saveViewLocalStateFromMutation( values: Partial & Partial, ): Promise { @@ -4635,10 +4599,7 @@ export class ClineProvider this._updateViewLocalStateFromMutation(values) } - /** - * Writes the durably persisted subset of a mutation (mode and currentApiConfigName) - * into the registered viewStates map for this view. - */ + /** Write the durable subset of a mutation into this view's viewStates entry. */ private async _persistViewLocalStateFromMutation( values: Partial & Partial, ): Promise { @@ -4657,9 +4618,7 @@ export class ClineProvider } } - /** - * Clear view-local state cache so that getState() falls back to ContextProxy defaults. - */ + /** Clear the buffer so getState() falls back to the shared values. */ private _clearViewLocalState(): void { this.viewLocalState = {} } From 07401e949ed72dcbfa681b9b554310d4b9af2f0a Mon Sep 17 00:00:00 2001 From: easonLiangWorldedtech <136036952+easonLiangWorldedtech@users.noreply.github.com> Date: Fri, 30 Oct 2026 12:30:34 +0800 Subject: [PATCH 17/42] fix(config): advance write generations on reset A write pending across resetAllState() must not restore its pre-reset value when it rejects afterwards; bump the generation of every tracked key during the reset, with a test. --- src/core/config/ContextProxy.ts | 5 +++++ .../config/__tests__/ContextProxy.spec.ts | 19 +++++++++++++++++++ 2 files changed, 24 insertions(+) diff --git a/src/core/config/ContextProxy.ts b/src/core/config/ContextProxy.ts index e5e4493627..ed71885347 100644 --- a/src/core/config/ContextProxy.ts +++ b/src/core/config/ContextProxy.ts @@ -723,6 +723,11 @@ export class ContextProxy { // Clear in-memory caches this.stateCache = {} this.secretCache = {} + // A write that started before this reset must not restore its pre-reset value when it + // rejects afterwards, so advance every generation the pending writes still hold. + for (const key of this.stateWriteGenerations.keys()) { + this.stateWriteGenerations.set(key, (this.stateWriteGenerations.get(key) ?? 0) + 1) + } await Promise.all([ ...GLOBAL_STATE_KEYS.map((key) => this.originalContext.globalState.update(key, undefined)), diff --git a/src/core/config/__tests__/ContextProxy.spec.ts b/src/core/config/__tests__/ContextProxy.spec.ts index fa0a7b3a0b..90a7be642b 100644 --- a/src/core/config/__tests__/ContextProxy.spec.ts +++ b/src/core/config/__tests__/ContextProxy.spec.ts @@ -142,6 +142,25 @@ describe("ContextProxy", () => { expect(proxy.getGlobalState("apiProvider")).toBe("openai") }) + it("should not restore a pre-reset value when a pending write rejects after reset", async () => { + let rejectPending: (error: Error) => void = () => {} + mockGlobalState.update.mockReset() + mockGlobalState.update.mockReturnValueOnce( + new Promise((_, reject) => { + rejectPending = reject + }), + ) + + const pending = proxy.updateGlobalState("apiProvider", "anthropic") + await proxy.resetAllState() + rejectPending(new Error("disk full")) + + await expect(pending).rejects.toThrow("disk full") + // The reset cleared the cache: restoring the pre-reset value would resurrect state + // that storage no longer holds. + expect(proxy.getGlobalState("apiProvider")).toBeUndefined() + }) + it("should bypass cache for pass-through state keys", async () => { // Setup mock return value mockGlobalState.get.mockReturnValue("pass-through-value") From 7d5bf3640a6824b26c85a03475a060129e9d52a1 Mon Sep 17 00:00:00 2001 From: easonLiangWorldedtech <136036952+easonLiangWorldedtech@users.noreply.github.com> Date: Fri, 30 Oct 2026 12:31:38 +0800 Subject: [PATCH 18/42] chore: align the shared view-identity docs with N1 --- packages/types/src/global-settings.ts | 6 +-- packages/types/src/vscode-extension-host.ts | 5 +-- src/core/config/ProviderSettingsManager.ts | 7 +-- src/core/webview/ClineProvider.ts | 47 ++++----------------- 4 files changed, 13 insertions(+), 52 deletions(-) diff --git a/packages/types/src/global-settings.ts b/packages/types/src/global-settings.ts index 63b1ef8998..9a040f6807 100644 --- a/packages/types/src/global-settings.ts +++ b/packages/types/src/global-settings.ts @@ -125,10 +125,8 @@ export const viewStateSchema = z.object({ currentApiConfigName: z.string().optional(), updatedAt: z.number().optional(), /** - * Host-minted capability token binding this entry to the webview that wrote it. - * Minted by the extension host (`crypto.randomUUID()`), delivered to that webview and - * never accepted from webview input. An entry is only re-adopted for a webview that - * presents this token, so a view cannot read another (e.g. closed) view's selections. + * Host-minted capability token binding this entry to the webview that wrote it; never + * accepted from webview input and only a matching token re-adopts the entry. */ claimToken: z.string().optional(), }) diff --git a/packages/types/src/vscode-extension-host.ts b/packages/types/src/vscode-extension-host.ts index c3b2fcd484..05fd0fdea4 100644 --- a/packages/types/src/vscode-extension-host.ts +++ b/packages/types/src/vscode-extension-host.ts @@ -725,10 +725,7 @@ export interface WebviewMessage { viewStateId?: string /** * For `webviewDidLaunch`: the host-minted claim previously delivered for `viewStateId`. - * The webview only echoes what it was given; the host enforces the match in - * `ClineProvider.setViewStateId` when a view registers this id, so a view cannot adopt - * another view's persisted selections. Forwarding these fields from the launch handler - * is wired by the follow-up launch unit. + * Enforced by `ClineProvider.setViewStateId`; launch forwarding ships in the wiring unit. */ viewStateClaim?: string taskId?: string diff --git a/src/core/config/ProviderSettingsManager.ts b/src/core/config/ProviderSettingsManager.ts index c9a9e7ae5b..fe7ec846cd 100644 --- a/src/core/config/ProviderSettingsManager.ts +++ b/src/core/config/ProviderSettingsManager.ts @@ -55,12 +55,7 @@ export const providerProfilesSchema = z.object({ export type ProviderProfiles = z.infer -/** - * Signals that a profile's configuration no longer exists. Callers that treat an - * already-deleted profile as an idempotent no-op branch on this type instead of - * matching error message text, which a profile name containing the phrase could - * otherwise spoof. - */ +/** Already-deleted profile: callers branch on this type instead of matching message text. */ export class ProviderSettingsNotFoundError extends Error { constructor(message: string) { super(message) diff --git a/src/core/webview/ClineProvider.ts b/src/core/webview/ClineProvider.ts index c4e13aa38b..fce3f1190e 100644 --- a/src/core/webview/ClineProvider.ts +++ b/src/core/webview/ClineProvider.ts @@ -445,12 +445,8 @@ export class ClineProvider public readonly viewId: string /** - * Stable identifier for persisted per-view state keys. - * Defaults to viewId until the webview reports its VS Code-persisted id. - * A durable entry under this id is bound to the webview that wrote it by a host-minted - * claim token (see setViewStateId), so the entry - and the profile its pin brings back - * into the state post - can outlive this instance without becoming adoptable by any - * other webview. + * Stable identifier for persisted per-view state keys; binds a durable entry to the + * webview that wrote it through the host-minted claim token. */ private viewStateId: string @@ -746,13 +742,8 @@ export class ClineProvider } /** - * Persists this view's non-secret selections through the serialized write queue. - * The write re-reads the map fresh and merges into the existing entry, removing the - * entry entirely when nothing persistable remains, so concurrent views cannot clobber it. - * The entry is keyed by the view id active when the change was made. Writes captured - * while the provider still holds its temporary (pre-launch) id persist under that id - * and are re-keyed to the stable view id when the webview registers one, so a change - * that lands before the launch message stays durable instead of being lost. + * Persist the non-secret selections through the serialized write queue, re-keying a + * pre-launch write to the stable id once the webview registers one. */ private async savePersistedViewState(values: Partial): Promise { // Capture the id at change time: a write belongs to the view that was active @@ -840,11 +831,8 @@ export class ClineProvider } /** - * Re-binds a claim-less viewStates entry to this webview with a freshly minted claim. - * Entries written before claims existed cannot be attributed to any webview, so their - * selections are dropped instead of being carried over: keeping them would let the new - * token re-expose them on a later launch, which is exactly the disclosure this binding - * exists to prevent. Runs through the serialized write queue like every other mutation. + * Re-bind a claim-less viewStates entry with a freshly minted claim; its unowned + * selections are dropped so the new token cannot re-expose them. */ private async rebindUnboundViewStateEntry(viewStateId: string): Promise { const claimToken = crypto.randomUUID() @@ -899,18 +887,7 @@ export class ClineProvider return Object.fromEntries([...liveEntries, ...closedEntries]) } - /** - * Re-keys this provider's temporary pre-launch viewStates entry to the newly - * registered stable id so pre-launch writes become durable under the stable key - * instead of orphaning under a session-local temporary id. Only the provider's own - * temporary id is eligible: an entry under a previously registered stable id belongs - * to that webview's storage and is left alone. When the stable entry already exists - * it wins and the temporary entry is dropped, because temporary ids are session - * counters that can collide across window reloads. Runs through the serialized write - * queue like every other viewStates mutation. An entry this instance never wrote is - * left alone, so a stale entry that happens to carry the same session-local name is - * not adopted. - */ + /** Re-key this instance's authored pre-launch entry to the stable id. */ private async rekeyPersistedViewStateEntry(nextViewStateId: string): Promise { const previousViewStateId = this.viewId @@ -958,14 +935,8 @@ export class ClineProvider } /** - * Registers this provider's stable view identifier and loads any persisted selections it owns. - * The identifier is sanitized so it remains a safe object key in the shared viewStates map. - * - * `presentedClaim` is the host-minted token this webview was given for that id. It is the - * only proof of ownership: an entry that carries a claim is loaded only when the presented - * token matches it, so a webview cannot adopt another (e.g. disposed, still durable) view's - * id and read that view's pinned profile - and the profile secrets copied into the state - * post - back out of it. The check runs before any re-keying or loading. + * Register the stable view id and load its persisted selections. An entry that carries a + * claim is loaded only when the presented host-minted token matches it. */ public async setViewStateId(viewStateId: string | undefined, presentedClaim?: string): Promise { // The webview generates this id on purpose - it has to survive a webview reload, From ffa03f5513f9dea7b53b61080b2c7ddcd3b050a5 Mon Sep 17 00:00:00 2001 From: easonLiangWorldedtech <136036952+easonLiangWorldedtech@users.noreply.github.com> Date: Fri, 30 Oct 2026 12:56:22 +0800 Subject: [PATCH 19/42] fix(webview): invalidate in-flight loads on reset and refresh sibling overlays --- src/core/webview/ClineProvider.ts | 23 ++++++- .../webview/__tests__/ClineProvider.spec.ts | 64 +++++++++++++++++++ 2 files changed, 86 insertions(+), 1 deletion(-) diff --git a/src/core/webview/ClineProvider.ts b/src/core/webview/ClineProvider.ts index fce3f1190e..08ad240df5 100644 --- a/src/core/webview/ClineProvider.ts +++ b/src/core/webview/ClineProvider.ts @@ -464,6 +464,10 @@ export class ClineProvider */ private viewLocalState: Partial = {} + // Bumped whenever the buffer is cleared (reset/import), so an in-flight load can tell + // that its captured state was invalidated while it awaited the profile lookup. + private viewLocalStateGeneration = 0 + /** * This view's pinned profile name from the view-local buffer. Exposed for * sibling-instance inspection (getAllInstances() filtering): `viewLocalState` @@ -1058,6 +1062,7 @@ export class ClineProvider /** Load non-secret persisted selections; in-flight buffer edits are reapplied on top. */ private async loadViewState(): Promise { + const loadedGeneration = this.viewLocalStateGeneration // A newer id registered while this load is in flight must win. const loadedForViewId = this.viewStateId @@ -1133,6 +1138,13 @@ export class ClineProvider } } + // A reset/import may have cleared the buffer while the lookup was in flight: + // republishing here would restore the pre-reset selection over the cleared state. + if (this.viewLocalStateGeneration !== loadedGeneration) { + this.log(`[loadViewState] Discarding state loaded before a reset for viewId ${this.viewId}`) + return + } + this.viewLocalState = mergedState this.log(`[loadViewState] Loaded state for viewId ${this.viewId}`) } catch (error) { @@ -3035,7 +3047,15 @@ export class ClineProvider if (signal.aborted) return id - // Refresh other views pinned to this profile so their overlays cannot go stale. + // Refresh other live views pinned to this profile so their buffered overlay cannot + // keep serving the pre-save settings under the same profile name. + for (const instance of ClineProvider.getAllInstances()) { + if (instance === this || instance._disposed || instance.pinnedProfileName !== name) { + continue + } + // Direct private access: compile-time safe across sibling instances. + await instance._saveViewLocalStateFromMutation({ apiConfiguration: providerSettings }) + } // Change the provider for the current task. // TODO: We should rename `buildApiHandler` for clarity (e.g. `getProviderClient`). @@ -4591,6 +4611,7 @@ export class ClineProvider /** Clear the buffer so getState() falls back to the shared values. */ private _clearViewLocalState(): void { + this.viewLocalStateGeneration += 1 this.viewLocalState = {} } diff --git a/src/core/webview/__tests__/ClineProvider.spec.ts b/src/core/webview/__tests__/ClineProvider.spec.ts index 017748f77f..341c5074c4 100644 --- a/src/core/webview/__tests__/ClineProvider.spec.ts +++ b/src/core/webview/__tests__/ClineProvider.spec.ts @@ -7198,6 +7198,70 @@ describe("ClineProvider", () => { await provider.dispose() }) + it("should discard a load that finishes after reset cleared the buffer", async () => { + const provider = new ClineProvider( + mockContext, + mockOutputChannel, + "sidebar", + new ContextProxy(mockContext), + new WebviewFocusTracker(), + ) + await provider["setViewStateId"]("stable-sidebar-view") + await provider.contextProxy.setValue("viewStates", { + "stable-sidebar-view": { mode: "architect", updatedAt: 1 }, + }) + + let releaseModes: () => void = () => {} + vi.spyOn(provider.customModesManager, "getCustomModes").mockImplementation( + () => + new Promise((resolve) => { + releaseModes = () => resolve([]) + }), + ) + + const load = provider["loadViewState"]() + // The reset clears the buffer while the load awaits the mode lookup. + provider["_clearViewLocalState"]() + releaseModes() + await load + + expect(provider["viewLocalState"]).toEqual({}) + await provider.dispose() + }) + + it("should refresh the buffered overlay of another view pinned to the saved profile", async () => { + const saver = new ClineProvider( + mockContext, + mockOutputChannel, + "sidebar", + new ContextProxy(mockContext), + new WebviewFocusTracker(), + ) + const pinned = new ClineProvider( + mockContext, + mockOutputChannel, + "editor", + new ContextProxy(mockContext), + new WebviewFocusTracker(), + ) + await pinned.setValue("currentApiConfigName", "shared-profile") + // @ts-ignore - The double only backs the profile-store calls of the save path. + saver.providerSettingsManager = { + saveConfig: vi.fn().mockResolvedValue("shared-id"), + listConfig: vi.fn().mockResolvedValue([{ name: "shared-profile", id: "shared-id" }]), + setModeConfig: vi.fn().mockResolvedValue(undefined), + } + const providerSettings = { apiProvider: providerIdentifiers.anthropic, apiKey: "fresh-key" } + + await saver.upsertProviderProfile("shared-profile", providerSettings, true) + + // The pinned view buffered a copy of the profile's settings; a non-activating save must + // refresh it, or its getState() keeps serving the pre-save configuration. + expect(pinned["viewLocalState"].apiConfiguration).toEqual(providerSettings) + await saver.dispose() + await pinned.dispose() + }) + it("should roll back the shared writes when setValues per-view persistence fails", async () => { const provider = new ClineProvider( mockContext, From 55eb38819aae3a77520fa6b6aeb3104381f86f82 Mon Sep 17 00:00:00 2001 From: easonLiangWorldedtech <136036952+easonLiangWorldedtech@users.noreply.github.com> Date: Fri, 30 Oct 2026 12:57:06 +0800 Subject: [PATCH 20/42] chore: tighten the shared view-state docs --- packages/types/src/global-settings.ts | 5 +---- packages/types/src/vscode-extension-host.ts | 5 +---- src/core/webview/ClineProvider.ts | 20 ++++---------------- 3 files changed, 6 insertions(+), 24 deletions(-) diff --git a/packages/types/src/global-settings.ts b/packages/types/src/global-settings.ts index 9a040f6807..9aa2179ae8 100644 --- a/packages/types/src/global-settings.ts +++ b/packages/types/src/global-settings.ts @@ -124,10 +124,7 @@ export const viewStateSchema = z.object({ mode: z.string().optional(), currentApiConfigName: z.string().optional(), updatedAt: z.number().optional(), - /** - * Host-minted capability token binding this entry to the webview that wrote it; never - * accepted from webview input and only a matching token re-adopts the entry. - */ + /** Host-minted token binding this entry to the webview that wrote it. */ claimToken: z.string().optional(), }) diff --git a/packages/types/src/vscode-extension-host.ts b/packages/types/src/vscode-extension-host.ts index 05fd0fdea4..225d32548b 100644 --- a/packages/types/src/vscode-extension-host.ts +++ b/packages/types/src/vscode-extension-host.ts @@ -723,10 +723,7 @@ export interface WebviewMessage { | "diagnosticsResponse" text?: string viewStateId?: string - /** - * For `webviewDidLaunch`: the host-minted claim previously delivered for `viewStateId`. - * Enforced by `ClineProvider.setViewStateId`; launch forwarding ships in the wiring unit. - */ + /** For `webviewDidLaunch`: the claim delivered for `viewStateId`, enforced by setViewStateId. */ viewStateClaim?: string taskId?: string editedMessageContent?: string diff --git a/src/core/webview/ClineProvider.ts b/src/core/webview/ClineProvider.ts index 08ad240df5..5251d68725 100644 --- a/src/core/webview/ClineProvider.ts +++ b/src/core/webview/ClineProvider.ts @@ -444,10 +444,7 @@ export class ClineProvider */ public readonly viewId: string - /** - * Stable identifier for persisted per-view state keys; binds a durable entry to the - * webview that wrote it through the host-minted claim token. - */ + /** Stable id for persisted per-view state keys, bound by the host-minted claim. */ private viewStateId: string /** @@ -745,10 +742,7 @@ export class ClineProvider return Object.assign(Object.create(null), viewStates) } - /** - * Persist the non-secret selections through the serialized write queue, re-keying a - * pre-launch write to the stable id once the webview registers one. - */ + /** Persist the non-secret selections through the serialized write queue. */ private async savePersistedViewState(values: Partial): Promise { // Capture the id at change time: a write belongs to the view that was active // when the change was made, even if a newer id is registered while it is queued. @@ -834,10 +828,7 @@ export class ClineProvider await write } - /** - * Re-bind a claim-less viewStates entry with a freshly minted claim; its unowned - * selections are dropped so the new token cannot re-expose them. - */ + /** Re-bind a claim-less entry with a fresh claim; unowned selections are dropped. */ private async rebindUnboundViewStateEntry(viewStateId: string): Promise { const claimToken = crypto.randomUUID() let rebound = false @@ -938,10 +929,7 @@ export class ClineProvider await write } - /** - * Register the stable view id and load its persisted selections. An entry that carries a - * claim is loaded only when the presented host-minted token matches it. - */ + /** Register the stable view id and load its persisted selections; a claim must match. */ public async setViewStateId(viewStateId: string | undefined, presentedClaim?: string): Promise { // The webview generates this id on purpose - it has to survive a webview reload, // which recreates the view on both sides - so the host cannot mint it instead. From 331e01d8919517eeef95788ebe19e40e4c3f4cf2 Mon Sep 17 00:00:00 2001 From: easonLiangWorldedtech <136036952+easonLiangWorldedtech@users.noreply.github.com> Date: Fri, 30 Oct 2026 14:31:49 +0800 Subject: [PATCH 21/42] fix(webview): address the N5 review findings (batch 1) - register configuration.customModes before setValues validates the mode - roll shared values back when a multi-key ContextProxy write rejects partway - pin a persisted profile name only with the configuration it resolves to - skip the buffer update when a reset ran during the durable save - guard the shared rollback with per-key write generations, not values alone - rebuild sibling task handlers when their pinned profile settings change --- src/core/config/ContextProxy.ts | 5 ++ src/core/webview/ClineProvider.ts | 89 ++++++++++++++----- .../webview/__tests__/ClineProvider.spec.ts | 6 +- 3 files changed, 78 insertions(+), 22 deletions(-) diff --git a/src/core/config/ContextProxy.ts b/src/core/config/ContextProxy.ts index ed71885347..ad3b1fb3da 100644 --- a/src/core/config/ContextProxy.ts +++ b/src/core/config/ContextProxy.ts @@ -433,6 +433,11 @@ export class ContextProxy { }) } + /** Current per-key write generation, used by callers whose rollback must not clobber a newer write. */ + public getStateWriteGeneration(key: K): number { + return this.stateWriteGenerations.get(key) ?? 0 + } + private getAllGlobalState(): GlobalState { return Object.fromEntries(GLOBAL_STATE_KEYS.map((key) => [key, this.getGlobalState(key)])) } diff --git a/src/core/webview/ClineProvider.ts b/src/core/webview/ClineProvider.ts index 5251d68725..be4be80440 100644 --- a/src/core/webview/ClineProvider.ts +++ b/src/core/webview/ClineProvider.ts @@ -1078,12 +1078,13 @@ export class ClineProvider } if (persisted?.currentApiConfigName) { - loadedState.currentApiConfigName = persisted.currentApiConfigName - try { const { name: _name, ...apiConfiguration } = await this.providerSettingsManager.getProfile({ name: persisted.currentApiConfigName, }) + // Pin the name only together with the configuration it resolves to: a name + // without its overlay would pair with whatever shared settings sit under it. + loadedState.currentApiConfigName = persisted.currentApiConfigName loadedState.apiConfiguration = apiConfiguration as ProviderSettings } catch (error) { this.log( @@ -3043,6 +3044,17 @@ export class ClineProvider } // Direct private access: compile-time safe across sibling instances. await instance._saveViewLocalStateFromMutation({ apiConfiguration: providerSettings }) + + // A sibling task running under this profile holds a handler built from the old + // settings: rebuild it so the conversation does not keep sending the old token. + if (instance.getCurrentTask()?.taskApiConfigName === name) { + const { + name: _recordName, + id: _recordId, + ...taskSettings + } = providerSettings as ProviderSettings & { name?: string; id?: string } + instance.updateTaskApiHandlerIfNeeded(taskSettings, { forceRebuild: true }) + } } // Change the provider for the current task. @@ -4518,15 +4530,20 @@ export class ClineProvider public async setValue(key: K, value: RooCodeSettings[K]) { const previousSharedValues = { [key]: this.contextProxy.getValue(key) } as RooCodeSettings + const writeGeneration = this.contextProxy.getStateWriteGeneration(key as never) await this.contextProxy.setValue(key, value) try { await this._saveViewLocalStateFromMutation({ [key]: value }) } catch (error) { // The per-view record did not land: restore the prior shared value so the two // persistence layers cannot diverge, then surface the original failure. - await this._restoreSharedValuesAfterFailedViewWrite(previousSharedValues, { - [key]: value, - } as RooCodeSettings) + await this._restoreSharedValuesAfterFailedViewWrite( + previousSharedValues, + { [key]: value } as RooCodeSettings, + // This write is the generation after the one captured before it: only the write + // that is still the newest for the key may be rolled back. + { [key]: writeGeneration + 1 } as Record, + ) throw error } } @@ -4559,13 +4576,35 @@ export class ClineProvider const previousSharedValues = Object.fromEntries( Object.keys(sanitizedValues).map((key) => [key, this.contextProxy.getValue(key as keyof RooCodeSettings)]), ) as RooCodeSettings - await this.contextProxy.setValues(sanitizedValues) + const writeGenerations = Object.fromEntries( + Object.keys(sanitizedValues).map((key) => [ + key, + // This write produces the next generation for the key. + this.contextProxy.getStateWriteGeneration(key as never) + 1, + ]), + ) as Record + try { + await this.contextProxy.setValues(sanitizedValues) + } catch (error) { + // A multi-key write can commit some keys before another rejects: put the captured + // previous values back so shared state does not stay half-applied. + try { + await this.contextProxy.setValues(previousSharedValues) + } catch (rollbackError) { + this.log( + `[ClineProvider#setValues] Failed to roll back a partially applied write: ${ + rollbackError instanceof Error ? rollbackError.message : String(rollbackError) + }`, + ) + } + throw error + } try { await this._saveViewLocalStateFromMutation(sanitizedValues) } catch (error) { // The per-view record did not land: restore the prior shared values so the two // persistence layers cannot diverge, then surface the original failure. - await this._restoreSharedValuesAfterFailedViewWrite(previousSharedValues, sanitizedValues) + await this._restoreSharedValuesAfterFailedViewWrite(previousSharedValues, sanitizedValues, writeGenerations) throw error } } @@ -4574,7 +4613,13 @@ export class ClineProvider private async _saveViewLocalStateFromMutation( values: Partial & Partial, ): Promise { + const generation = this.viewLocalStateGeneration await this._persistViewLocalStateFromMutation(values) + // A reset that ran while the durable write was pending cleared the buffer: applying + // the pre-reset value now would resurrect it. + if (this.viewLocalStateGeneration !== generation) { + return + } this._updateViewLocalStateFromMutation(values) } @@ -5168,6 +5213,14 @@ export class ClineProvider configuration: RooCodeSettings = {}, ): Promise { if (configuration) { + // Register custom modes before setValues: setValues validates `mode` against + // getCustomModes(), so a mode supplied in the same call would otherwise be dropped. + if (configuration.customModes?.length) { + for (const mode of configuration.customModes) { + await this.customModesManager.updateCustomMode(mode.slug, mode) + } + } + await this.setValues(configuration) if (configuration.allowedCommands) { @@ -5195,16 +5248,6 @@ export class ClineProvider if (configuration.currentApiConfigName) { await this.setProviderProfile(configuration.currentApiConfigName) } - - // Register custom modes so the CustomModesManager knows about them. - // setValues writes to global state, but the manager overwrites that - // when it merges .roomodes + global settings on refresh. Persisting - // via updateCustomMode ensures modes survive the merge cycle. - if (configuration.customModes?.length) { - for (const mode of configuration.customModes) { - await this.customModesManager.updateCustomMode(mode.slug, mode) - } - } } const { @@ -6436,14 +6479,20 @@ export class ClineProvider private async _restoreSharedValuesAfterFailedViewWrite( previous: RooCodeSettings, attempted: RooCodeSettings, + generations: Record = {}, ): Promise { // Roll back only the keys this attempt wrote and that still hold the value it wrote. - // A concurrent provider may have written a newer value in the meantime; restoring the - // captured previous value would then clobber it for every view that reads shared state. + // A concurrent provider may have written a newer value in the meantime - even the same + // value - so the per-key write generation must also still match; restoring otherwise + // would clobber that newer write for every view that reads shared state. const rollback: RooCodeSettings = {} as RooCodeSettings for (const key of Object.keys(attempted) as (keyof RooCodeSettings)[]) { - if (this.contextProxy.getValue(key) === attempted[key]) { + const generation = generations[key] + if ( + this.contextProxy.getValue(key) === attempted[key] && + (generation === undefined || this.contextProxy.getStateWriteGeneration(key as never) === generation) + ) { ;(rollback as Record)[key] = previous[key] } } diff --git a/src/core/webview/__tests__/ClineProvider.spec.ts b/src/core/webview/__tests__/ClineProvider.spec.ts index 341c5074c4..d38a49b6e7 100644 --- a/src/core/webview/__tests__/ClineProvider.spec.ts +++ b/src/core/webview/__tests__/ClineProvider.spec.ts @@ -6562,7 +6562,7 @@ describe("ClineProvider", () => { await provider.dispose() }) - it("should keep the persisted profile name and log when the profile lookup fails", async () => { + it("should not pin the persisted profile name when the profile lookup fails", async () => { const provider = new ClineProvider( mockContext, mockOutputChannel, @@ -6575,7 +6575,9 @@ describe("ClineProvider", () => { provider.providerSettingsManager = { getProfile: vi.fn().mockRejectedValue(new Error("profile missing")) } await provider.saveViewState("currentApiConfigName", "my-profile") await provider["setViewStateId"]("stable-sidebar-view") - expect(provider["viewLocalState"].currentApiConfigName).toBe("my-profile") + // The name is pinned only with its resolved configuration: otherwise getState() + // would pair the missing profile's name with unrelated shared settings. + expect(provider["viewLocalState"]).not.toHaveProperty("currentApiConfigName") expect(provider["viewLocalState"]).not.toHaveProperty("apiConfiguration") expect(logSpy).toHaveBeenCalledWith(expect.stringContaining("Unable to resolve API profile 'my-profile'")) await provider.dispose() From 9827245fb33d64fb9e42397c61557112f15e7bff Mon Sep 17 00:00:00 2001 From: easonLiangWorldedtech <136036952+easonLiangWorldedtech@users.noreply.github.com> Date: Fri, 30 Oct 2026 14:33:57 +0800 Subject: [PATCH 22/42] fix(webview): address the N5 review findings (batch 2) - ContextProxy tracks the last persisted value per key and rolls a failed write back to it, with a both-writes-reject test - deleteProviderProfile retries the settings-manager name update and reports an incomplete repair after posting state - deleteProviderProfile re-pins sibling views still buffered on the deleted profile --- .../config/__tests__/ContextProxy.spec.ts | 29 ++++++++++ src/core/webview/ClineProvider.ts | 54 +++++++++++++++---- 2 files changed, 74 insertions(+), 9 deletions(-) diff --git a/src/core/config/__tests__/ContextProxy.spec.ts b/src/core/config/__tests__/ContextProxy.spec.ts index 90a7be642b..edb04d0d4d 100644 --- a/src/core/config/__tests__/ContextProxy.spec.ts +++ b/src/core/config/__tests__/ContextProxy.spec.ts @@ -161,6 +161,35 @@ describe("ContextProxy", () => { expect(proxy.getGlobalState("apiProvider")).toBeUndefined() }) + it("should restore the last persisted value when two overlapping writes both reject", async () => { + await proxy.updateGlobalState("apiProvider", "anthropic") + mockGlobalState.update.mockReset() + let rejectFirst: (error: Error) => void = () => {} + let rejectSecond: (error: Error) => void = () => {} + mockGlobalState.update + .mockReturnValueOnce( + new Promise((_, reject) => { + rejectFirst = reject + }), + ) + .mockReturnValueOnce( + new Promise((_, reject) => { + rejectSecond = reject + }), + ) + + const firstWrite = proxy.updateGlobalState("apiProvider", "openrouter") + const secondWrite = proxy.updateGlobalState("apiProvider", "deepseek") + rejectSecond(new Error("second failed")) + await expect(secondWrite).rejects.toThrow("second failed") + rejectFirst(new Error("first failed")) + await expect(firstWrite).rejects.toThrow("first failed") + + // Neither attempt reached storage: the cache must hold the last persisted value, + // not the first attempt's unpersisted value. + expect(proxy.getGlobalState("apiProvider")).toBe("anthropic") + }) + it("should bypass cache for pass-through state keys", async () => { // Setup mock return value mockGlobalState.get.mockReturnValue("pass-through-value") diff --git a/src/core/webview/ClineProvider.ts b/src/core/webview/ClineProvider.ts index be4be80440..dd68c6be4b 100644 --- a/src/core/webview/ClineProvider.ts +++ b/src/core/webview/ClineProvider.ts @@ -3150,15 +3150,28 @@ export class ClineProvider // currentApiConfigName naming it, so a later export would write a selection the // profile list no longer contains (and import would silently pick another profile). // Point the manager at the survivor too. + let managerNameUpdateFailure: Error | undefined if (deletedWasGlobal) { try { await this.providerSettingsManager.activateProfile({ name: profileToActivate }) - } catch (error) { - this.log( - `[deleteProviderProfile] Failed to update the settings manager's current profile to '${profileToActivate}': ${ - error instanceof Error ? error.message : String(error) - }`, - ) + } catch (firstError) { + try { + // Retry once: a stale manager name would be exported as a selection the + // profile list no longer contains. + await this.providerSettingsManager.activateProfile({ name: profileToActivate }) + } catch (retryError) { + this.log( + `[deleteProviderProfile] Failed to update the settings manager's current profile to '${profileToActivate}' after retry: ${ + retryError instanceof Error ? retryError.message : String(retryError) + } (first attempt: ${firstError instanceof Error ? firstError.message : String(firstError)})`, + ) + // The deletion has committed: finish the shared-state repair and post it, then + // surface the incomplete manager update to the caller. + managerNameUpdateFailure = new Error( + `Profile '${profileToDelete.name}' was deleted but the settings manager still names it as current.`, + { cause: retryError }, + ) + } } } @@ -3189,11 +3202,34 @@ export class ClineProvider } } - // Re-pin other live views still buffered on the deleted profile: their - // buffer and durable viewStates entry would otherwise keep serving the - // deleted profile's name and configuration. + // Re-pin other live views still buffered on the deleted profile: their buffer and + // durable viewStates entry would otherwise keep serving the deleted profile's name + // and configuration. + for (const instance of ClineProvider.getAllInstances()) { + if (instance === this || instance._disposed || instance.pinnedProfileName !== profileToDelete.name) { + continue + } + const values: Partial & Partial = { + currentApiConfigName: profileToActivate, + } + if (survivingSettings) { + values.apiConfiguration = survivingSettings + } + // Direct private access: compile-time safe across sibling instances. + await instance._saveViewLocalStateFromMutation(values) + await instance.postStateToWebview().catch((postError: unknown) => { + this.log( + `[deleteProviderProfile] failed to post re-pinned state to a sibling view: ${ + postError instanceof Error ? postError.message : String(postError) + }`, + ) + }) + } await this.postStateToWebview() + if (managerNameUpdateFailure) { + throw managerNameUpdateFailure + } } private async persistStickyProviderProfileToCurrentTask( From 341d7204e853b0e924323057bb6cd937bfd23231 Mon Sep 17 00:00:00 2001 From: Eason Liang <136036952+easonLiangWorldedtech@users.noreply.github.com> Date: Sun, 1 Nov 2026 21:38:34 +0800 Subject: [PATCH 23/42] chore(lint): prune suppressions left stale by the upstream merge --- src/eslint-suppressions.json | 306 ++++++++++++++++++++++++++++++++++- 1 file changed, 303 insertions(+), 3 deletions(-) diff --git a/src/eslint-suppressions.json b/src/eslint-suppressions.json index 9582b5032e..c5b672fd4a 100644 --- a/src/eslint-suppressions.json +++ b/src/eslint-suppressions.json @@ -1,4 +1,89 @@ { + "__mocks__/fs/promises.ts": { + "@typescript-eslint/no-explicit-any": { + "count": 4 + } + }, + "__tests__/ClineProvider.delegation.spec.ts": { + "@typescript-eslint/no-explicit-any": { + "count": 9 + } + }, + "__tests__/ClineProvider.history-resume-delegation.spec.ts": { + "@typescript-eslint/no-explicit-any": { + "count": 70 + } + }, + "__tests__/abandonSubtask.spec.ts": { + "@typescript-eslint/no-explicit-any": { + "count": 20 + } + }, + "__tests__/api-subtask.spec.ts": { + "@typescript-eslint/no-explicit-any": { + "count": 4 + } + }, + "__tests__/delegation-concurrent.spec.ts": { + "@typescript-eslint/no-explicit-any": { + "count": 6 + } + }, + "__tests__/delegation-events.spec.ts": { + "@typescript-eslint/no-explicit-any": { + "count": 6 + } + }, + "__tests__/migrateSettings.spec.ts": { + "@typescript-eslint/no-explicit-any": { + "count": 4 + } + }, + "__tests__/nested-delegation-resume.spec.ts": { + "@typescript-eslint/no-explicit-any": { + "count": 19 + } + }, + "__tests__/new-task-delegation.spec.ts": { + "@typescript-eslint/no-explicit-any": { + "count": 8 + } + }, + "activate/CodeActionProvider.ts": { + "@typescript-eslint/no-explicit-any": { + "count": 1 + } + }, + "activate/__tests__/CodeActionProvider.spec.ts": { + "@typescript-eslint/no-explicit-any": { + "count": 10 + } + }, + "activate/__tests__/handleUri.spec.ts": { + "@typescript-eslint/no-explicit-any": { + "count": 14 + } + }, + "activate/__tests__/registerCommands.spec.ts": { + "@typescript-eslint/no-explicit-any": { + "count": 2 + } + }, + "activate/registerCodeActions.ts": { + "@typescript-eslint/no-explicit-any": { + "count": 2 + } + }, + "activate/registerCommands.ts": { + "@typescript-eslint/no-explicit-any": { + "count": 1 + } + }, + "activate/registerTerminalActions.ts": { + "@typescript-eslint/no-explicit-any": { + "count": 1 + } + }, "api/providers/__tests__/anthropic-vertex.spec.ts": { "@typescript-eslint/no-explicit-any": { "count": 31 @@ -84,6 +169,11 @@ "count": 36 } }, + "api/providers/__tests__/lm-studio-timeout.spec.ts": { + "@typescript-eslint/no-explicit-any": { + "count": 3 + } + }, "api/providers/__tests__/mimo.spec.ts": { "@typescript-eslint/no-explicit-any": { "count": 18 @@ -319,6 +409,11 @@ "count": 3 } }, + "api/providers/qwen-code.ts": { + "@typescript-eslint/no-explicit-any": { + "count": 1 + } + }, "api/providers/requesty.ts": { "@typescript-eslint/no-explicit-any": { "count": 3 @@ -496,7 +591,7 @@ }, "core/checkpoints/__tests__/checkpoint.test.ts": { "@typescript-eslint/no-explicit-any": { - "count": 3 + "count": 5 } }, "core/checkpoints/index.ts": { @@ -716,12 +811,12 @@ }, "core/task/__tests__/ask-clear-approval-buttons.spec.ts": { "@typescript-eslint/no-explicit-any": { - "count": 18 + "count": 19 } }, "core/task/__tests__/ask-queued-message-drain.spec.ts": { "@typescript-eslint/no-explicit-any": { - "count": 17 + "count": 18 } }, "core/task/__tests__/flushPendingToolResultsToHistory.spec.ts": { @@ -939,6 +1034,11 @@ "count": 12 } }, + "core/webview/__tests__/checkpointRestoreHandler.spec.ts": { + "@typescript-eslint/no-explicit-any": { + "count": 3 + } + }, "core/webview/__tests__/diagnosticsHandler.spec.ts": { "@typescript-eslint/no-explicit-any": { "count": 7 @@ -959,6 +1059,11 @@ "count": 4 } }, + "core/webview/__tests__/webviewMessageHandler.checkpoint.spec.ts": { + "@typescript-eslint/no-explicit-any": { + "count": 5 + } + }, "core/webview/__tests__/webviewMessageHandler.cloudAuth.spec.ts": { "@typescript-eslint/no-explicit-any": { "count": 3 @@ -1009,6 +1114,146 @@ "count": 5 } }, + "extension/__tests__/api-delete-queued-message.spec.ts": { + "@typescript-eslint/no-explicit-any": { + "count": 1 + } + }, + "extension/__tests__/api-send-message.spec.ts": { + "@typescript-eslint/no-explicit-any": { + "count": 7 + } + }, + "extension/api.ts": { + "@typescript-eslint/no-explicit-any": { + "count": 9 + } + }, + "i18n/index.ts": { + "@typescript-eslint/no-explicit-any": { + "count": 1 + } + }, + "i18n/setup.ts": { + "@typescript-eslint/no-explicit-any": { + "count": 1 + } + }, + "integrations/editor/DiffViewProvider.ts": { + "@typescript-eslint/no-explicit-any": { + "count": 1 + } + }, + "integrations/editor/__tests__/DiffViewProvider.spec.ts": { + "@typescript-eslint/no-explicit-any": { + "count": 310 + } + }, + "integrations/editor/__tests__/EditorUtils.spec.ts": { + "@typescript-eslint/no-explicit-any": { + "count": 3 + } + }, + "integrations/kimi-code/__tests__/oauth.spec.ts": { + "@typescript-eslint/no-explicit-any": { + "count": 1 + } + }, + "integrations/misc/__tests__/export-markdown.spec.ts": { + "@typescript-eslint/no-explicit-any": { + "count": 1 + } + }, + "integrations/misc/__tests__/open-file.spec.ts": { + "@typescript-eslint/no-explicit-any": { + "count": 11 + } + }, + "integrations/misc/__tests__/performance/processCarriageReturns.benchmark.ts": { + "@typescript-eslint/no-explicit-any": { + "count": 2 + } + }, + "integrations/terminal/__tests__/ExecaTerminalProcess.spec.ts": { + "@typescript-eslint/no-explicit-any": { + "count": 10 + } + }, + "integrations/terminal/__tests__/OutputInterceptor.test.ts": { + "@typescript-eslint/no-explicit-any": { + "count": 5 + } + }, + "integrations/terminal/__tests__/TerminalProcess.spec.ts": { + "@typescript-eslint/no-explicit-any": { + "count": 7 + } + }, + "integrations/terminal/__tests__/TerminalProcess.test.ts": { + "@typescript-eslint/no-explicit-any": { + "count": 2 + } + }, + "integrations/terminal/__tests__/TerminalProcessExec.bash.spec.ts": { + "@typescript-eslint/no-explicit-any": { + "count": 2 + } + }, + "integrations/terminal/__tests__/TerminalProcessExec.cmd.spec.ts": { + "@typescript-eslint/no-explicit-any": { + "count": 1 + } + }, + "integrations/terminal/__tests__/TerminalProcessExec.pwsh.spec.ts": { + "@typescript-eslint/no-explicit-any": { + "count": 1 + } + }, + "integrations/terminal/__tests__/TerminalProcessInterpretExitCode.spec.ts": { + "@typescript-eslint/no-explicit-any": { + "count": 3 + } + }, + "integrations/terminal/__tests__/TerminalProfile.spec.ts": { + "@typescript-eslint/no-explicit-any": { + "count": 34 + } + }, + "integrations/terminal/__tests__/TerminalRegistry.spec.ts": { + "@typescript-eslint/no-explicit-any": { + "count": 22 + } + }, + "integrations/terminal/__tests__/setupTerminalTests.ts": { + "@typescript-eslint/no-explicit-any": { + "count": 1 + } + }, + "integrations/terminal/__tests__/streamUtils/bashStream.ts": { + "@typescript-eslint/no-explicit-any": { + "count": 1 + } + }, + "integrations/terminal/__tests__/streamUtils/cmdStream.ts": { + "@typescript-eslint/no-explicit-any": { + "count": 1 + } + }, + "integrations/terminal/__tests__/streamUtils/index.ts": { + "@typescript-eslint/no-explicit-any": { + "count": 2 + } + }, + "integrations/terminal/__tests__/streamUtils/pwshStream.ts": { + "@typescript-eslint/no-explicit-any": { + "count": 1 + } + }, + "integrations/theme/getTheme.ts": { + "@typescript-eslint/no-explicit-any": { + "count": 9 + } + }, "services/__tests__/zoo-code-auth.test.ts": { "@typescript-eslint/no-explicit-any": { "count": 3 @@ -1323,5 +1568,60 @@ "@typescript-eslint/no-explicit-any": { "count": 2 } + }, + "shared/__tests__/api.spec.ts": { + "@typescript-eslint/no-explicit-any": { + "count": 8 + } + }, + "shared/__tests__/embeddingModels.spec.ts": { + "@typescript-eslint/no-explicit-any": { + "count": 1 + } + }, + "shared/__tests__/modes-empty-prompt-component.spec.ts": { + "@typescript-eslint/no-explicit-any": { + "count": 1 + } + }, + "shared/api.ts": { + "@typescript-eslint/no-explicit-any": { + "count": 2 + } + }, + "shared/checkExistApiConfig.ts": { + "@typescript-eslint/no-explicit-any": { + "count": 1 + } + }, + "shared/cost.ts": { + "@typescript-eslint/no-explicit-any": { + "count": 1 + } + }, + "shared/parse-command.ts": { + "@typescript-eslint/no-explicit-any": { + "count": 1 + } + }, + "shared/support-prompt.ts": { + "@typescript-eslint/no-explicit-any": { + "count": 5 + } + }, + "shared/tools.ts": { + "@typescript-eslint/no-explicit-any": { + "count": 1 + } + }, + "shared/utils/__tests__/requesty.spec.ts": { + "@typescript-eslint/no-explicit-any": { + "count": 2 + } + }, + "vitest.setup.ts": { + "@typescript-eslint/no-explicit-any": { + "count": 1 + } } } From b1016446f9a0d4c60627a64fbbbd2756303296b3 Mon Sep 17 00:00:00 2001 From: eason liang <136036952+easonLiangWorldedtech@users.noreply.github.com> Date: Wed, 4 Nov 2026 01:29:00 +0800 Subject: [PATCH 24/42] fix(webview): address #2237 review findings on per-view restore - ContextProxy: seed the persisted-value map in initialize so a failed write on a key that has never been written through this proxy rolls the cache back to the value storage actually holds instead of an overlapping write's pending value. - ClineProvider.loadViewState: keep the profile name and the settings it resolved to as one pair; a profile name this view changed while the lookup was in flight no longer inherits the loaded profile's configuration. - ClineProvider.getState: read this view's restored mode from the buffer - getState() is what task creation and getStateToPostToWebview read, so a restored mode has to be visible there. - ClineProvider.deleteProviderProfile: clear the settings overlay of every view re-pointed away from the deleted profile when the survivor's settings cannot be resolved, and rebuild the live task (in this view and in sibling views) that still names the deleted profile. - ClineProvider.setValues: roll a partially applied shared write back through the generation-guarded helper instead of replaying every captured value. Tests: 1 new ContextProxy case and 4 new ClineProvider cases, each red before its fix and green after it; 43 suites / 1188 tests pass under core/webview + core/config. --- src/core/config/ContextProxy.ts | 5 + .../config/__tests__/ContextProxy.spec.ts | 35 ++++ src/core/webview/ClineProvider.ts | 82 +++++--- .../webview/__tests__/ClineProvider.spec.ts | 198 +++++++++++++++++- 4 files changed, 290 insertions(+), 30 deletions(-) diff --git a/src/core/config/ContextProxy.ts b/src/core/config/ContextProxy.ts index ad3b1fb3da..2852ec5453 100644 --- a/src/core/config/ContextProxy.ts +++ b/src/core/config/ContextProxy.ts @@ -96,6 +96,11 @@ export class ContextProxy { try { // Revert to original assignment this.stateCache[key] = this.originalContext.globalState.get(key) + // Storage is the baseline of the rollback path: without this entry, a failed write + // on a key that has never been written through this proxy falls back to the + // previous cached value - which an overlapping write may have made its own + // unpersisted one. + this.statePersistedCache.set(key, this.stateCache[key]) } catch (error) { logger.error(`Error loading global ${key}: ${error instanceof Error ? error.message : String(error)}`) } diff --git a/src/core/config/__tests__/ContextProxy.spec.ts b/src/core/config/__tests__/ContextProxy.spec.ts index edb04d0d4d..fdd497bc79 100644 --- a/src/core/config/__tests__/ContextProxy.spec.ts +++ b/src/core/config/__tests__/ContextProxy.spec.ts @@ -190,6 +190,41 @@ describe("ContextProxy", () => { expect(proxy.getGlobalState("apiProvider")).toBe("anthropic") }) + it("should restore the loaded value when overlapping writes reject with no prior write", async () => { + // Cold start: storage holds the value but nothing has been written through this + // proxy yet, so the persisted-value map has no entry for the key. + mockGlobalState.get.mockImplementation((key: string) => (key === "apiProvider" ? "openai" : undefined)) + const coldProxy = new ContextProxy(mockContext) + await coldProxy.initialize() + expect(coldProxy.getGlobalState("apiProvider")).toBe("openai") + + mockGlobalState.update.mockReset() + let rejectFirst: (error: Error) => void = () => {} + let rejectSecond: (error: Error) => void = () => {} + mockGlobalState.update + .mockReturnValueOnce( + new Promise((_, reject) => { + rejectFirst = reject + }), + ) + .mockReturnValueOnce( + new Promise((_, reject) => { + rejectSecond = reject + }), + ) + + const firstWrite = coldProxy.updateGlobalState("apiProvider", "openrouter") + const secondWrite = coldProxy.updateGlobalState("apiProvider", "deepseek") + rejectSecond(new Error("second failed")) + await expect(secondWrite).rejects.toThrow("second failed") + rejectFirst(new Error("first failed")) + await expect(firstWrite).rejects.toThrow("first failed") + + // The second write's `previousCachedValue` is the first write's pending value, so the + // fallback branch would leave a value that storage never accepted. + expect(coldProxy.getGlobalState("apiProvider")).toBe("openai") + }) + it("should bypass cache for pass-through state keys", async () => { // Setup mock return value mockGlobalState.get.mockReturnValue("pass-through-value") diff --git a/src/core/webview/ClineProvider.ts b/src/core/webview/ClineProvider.ts index dd68c6be4b..aed20a89ba 100644 --- a/src/core/webview/ClineProvider.ts +++ b/src/core/webview/ClineProvider.ts @@ -1127,6 +1127,19 @@ export class ClineProvider } } + // The profile name and the settings it resolved to are one pair: the configuration loaded + // above belongs to the profile the lookup asked for, so it must not stay parked under a + // name this view changed while the lookup was in flight. A name this view changed on its + // own pins nothing - reads fall back to the shared settings, exactly as every other + // name-only write behaves. + if ( + loadedState.apiConfiguration !== undefined && + Object.is(preLoadBuffer.apiConfiguration, postLoadBuffer.apiConfiguration) && + mergedState.currentApiConfigName !== loadedState.currentApiConfigName + ) { + delete mergedState.apiConfiguration + } + // A reset/import may have cleared the buffer while the lookup was in flight: // republishing here would restore the pre-reset selection over the cleared state. if (this.viewLocalStateGeneration !== loadedGeneration) { @@ -3187,18 +3200,33 @@ export class ClineProvider await this.contextProxy.setValue("currentApiConfigName", profileToActivate) } - if ((deletedWasGlobal || viewWasPinnedToDeleted) && survivingSettings) { - // The deleted profile was the active one (globally, or for this view), so - // the shared provider keys still carry its settings; replace them so - // getState() reports the surviving profile's configuration. - await this.contextProxy.setProviderSettings(survivingSettings) + if (deletedWasGlobal || viewWasPinnedToDeleted) { + if (survivingSettings) { + // The deleted profile was the active one (globally, or for this view), so + // the shared provider keys still carry its settings; replace them so + // getState() reports the surviving profile's configuration. + await this.contextProxy.setProviderSettings(survivingSettings) + + if (viewWasPinnedToDeleted) { + // This view's nested overlay (viewLocalState.apiConfiguration, seeded + // by loadViewState) still serves the deleted profile's configuration: + // replace it with the survivor's so the re-pointed pin serves matching + // settings. A view pinned to another profile keeps its own overlay. + await this._saveViewLocalStateFromMutation({ apiConfiguration: survivingSettings }) + } - if (viewWasPinnedToDeleted) { - // This view's nested overlay (viewLocalState.apiConfiguration, seeded - // by loadViewState) still serves the deleted profile's configuration: - // replace it with the survivor's so the re-pointed pin serves matching - // settings. A view pinned to another profile keeps its own overlay. - await this._saveViewLocalStateFromMutation({ apiConfiguration: survivingSettings }) + // A live task of this view that runs under the deleted profile keeps the handler + // built from its settings and the deleted sticky name until it is rebuilt - the same + // rule the activating-save branch applies. + if (this.getCurrentTask()?.taskApiConfigName === profileToDelete.name) { + this.updateTaskApiHandlerIfNeeded(survivingSettings, { forceRebuild: true }) + await this.persistStickyProviderProfileToCurrentTask(profileToActivate) + } + } else if (viewWasPinnedToDeleted) { + // The survivor's settings never resolved: this view's pin now names the survivor, so + // its overlay must stop serving the deleted profile's configuration and fall back to + // the shared settings instead. + await this._saveViewLocalStateFromMutation({ apiConfiguration: undefined }) } } @@ -3211,12 +3239,19 @@ export class ClineProvider } const values: Partial & Partial = { currentApiConfigName: profileToActivate, - } - if (survivingSettings) { - values.apiConfiguration = survivingSettings + // Either the survivor's settings or an explicit clear: a view re-pointed away from the + // deleted profile must not keep serving that profile's configuration. + apiConfiguration: survivingSettings, } // Direct private access: compile-time safe across sibling instances. await instance._saveViewLocalStateFromMutation(values) + // The re-pinned buffer alone does not reach a live task in that view: it still runs on a + // handler built from the deleted profile's settings and still names the deleted profile as + // its sticky profile. + if (survivingSettings && instance.getCurrentTask()?.taskApiConfigName === profileToDelete.name) { + instance.updateTaskApiHandlerIfNeeded(survivingSettings, { forceRebuild: true }) + await instance.persistStickyProviderProfileToCurrentTask(profileToActivate) + } await instance.postStateToWebview().catch((postError: unknown) => { this.log( `[deleteProviderProfile] failed to post re-pinned state to a sibling view: ${ @@ -4420,7 +4455,10 @@ export class ClineProvider terminalZshP10k: stateValues.terminalZshP10k ?? false, terminalZdotdir: stateValues.terminalZdotdir ?? false, terminalProfile: stateValues.terminalProfile, - mode: stateValues.mode ?? defaultModeSlug, + // A per-view restored or edited mode lives in this view's buffer, and getState() is + // what task creation and getStateToPostToWebview read: the shared store only carries the + // mode the last committing view chose. + mode: this.viewLocalState.mode ?? stateValues.mode ?? defaultModeSlug, language: stateValues.language ?? formatLanguage(vscode.env.language), mcpEnabled: stateValues.mcpEnabled ?? true, mcpServers: this.mcpHub?.getAllServers() ?? [], @@ -4623,16 +4661,10 @@ export class ClineProvider await this.contextProxy.setValues(sanitizedValues) } catch (error) { // A multi-key write can commit some keys before another rejects: put the captured - // previous values back so shared state does not stay half-applied. - try { - await this.contextProxy.setValues(previousSharedValues) - } catch (rollbackError) { - this.log( - `[ClineProvider#setValues] Failed to roll back a partially applied write: ${ - rollbackError instanceof Error ? rollbackError.message : String(rollbackError) - }`, - ) - } + // previous values back so shared state does not stay half-applied. Route through the + // same guarded restore the failed per-view write below uses - a key that a concurrent + // provider has since written must not be clobbered by this rollback. + await this._restoreSharedValuesAfterFailedViewWrite(previousSharedValues, sanitizedValues, writeGenerations) throw error } try { diff --git a/src/core/webview/__tests__/ClineProvider.spec.ts b/src/core/webview/__tests__/ClineProvider.spec.ts index d38a49b6e7..adce1fadab 100644 --- a/src/core/webview/__tests__/ClineProvider.spec.ts +++ b/src/core/webview/__tests__/ClineProvider.spec.ts @@ -5647,6 +5647,137 @@ describe("ClineProvider", () => { await provider.dispose() }) + + it("clears the settings overlay of a view re-pinned when the survivor's settings cannot be resolved", async () => { + const contextProxy = new ContextProxy(mockContext) + const deleter = new ClineProvider( + mockContext, + mockOutputChannel, + "sidebar", + contextProxy, + new WebviewFocusTracker(), + ) + const pinned = new ClineProvider( + mockContext, + mockOutputChannel, + "editor", + new ContextProxy(mockContext), + new WebviewFocusTracker(), + ) + const profileToDelete: ProviderSettingsEntry = { name: "deleted", id: "deleted-id" } + const deletedSettings = { apiProvider: providerIdentifiers.openrouter, openRouterModelId: "deleted-model" } + + await contextProxy.setValue("listApiConfigMeta", [ + { name: "deleted", id: "deleted-id" }, + { name: "survivor", id: "survivor-id" }, + ]) + await contextProxy.setValue("currentApiConfigName", "deleted") + await contextProxy.setProviderSettings(deletedSettings) + + for (const view of [deleter, pinned]) { + await view.saveViewState("currentApiConfigName", "deleted") + // The buffer a completed loadViewState leaves behind: this view serves the deleted + // profile's configuration. + await view["_saveViewLocalStateFromMutation"]({ apiConfiguration: deletedSettings }) + } + + vi.spyOn(deleter["providerSettingsManager"], "deleteConfig").mockResolvedValue(undefined) + vi.spyOn(deleter["providerSettingsManager"], "activateProfile").mockResolvedValue({ + name: "survivor", + id: "survivor-id", + apiProvider: providerIdentifiers.anthropic, + }) + vi.spyOn(deleter["providerSettingsManager"], "getProfile").mockRejectedValue( + new Error("profile store unavailable"), + ) + + await deleter.deleteProviderProfile(profileToDelete) + + // Both views are re-pointed at the survivor, so neither may keep serving the deleted + // profile's configuration under the survivor's name. + expect(deleter["viewLocalState"].currentApiConfigName).toBe("survivor") + expect(deleter["viewLocalState"]).not.toHaveProperty("apiConfiguration") + expect(pinned["viewLocalState"].currentApiConfigName).toBe("survivor") + expect(pinned["viewLocalState"]).not.toHaveProperty("apiConfiguration") + + await deleter.dispose() + await pinned.dispose() + }) + + it("rebuilds a live task that still runs on the deleted profile, in this view and in a sibling view", async () => { + const contextProxy = new ContextProxy(mockContext) + const deleter = new ClineProvider( + mockContext, + mockOutputChannel, + "sidebar", + contextProxy, + new WebviewFocusTracker(), + ) + const sibling = new ClineProvider( + mockContext, + mockOutputChannel, + "editor", + new ContextProxy(mockContext), + new WebviewFocusTracker(), + ) + const profileToDelete: ProviderSettingsEntry = { name: "deleted", id: "deleted-id" } + const survivingSettings = { apiProvider: providerIdentifiers.anthropic, apiKey: "survivor-key" } + + await contextProxy.setValue("listApiConfigMeta", [ + { name: "deleted", id: "deleted-id" }, + { name: "survivor", id: "survivor-id" }, + ]) + await contextProxy.setValue("currentApiConfigName", "deleted") + + const views = [deleter, sibling] + const tasks = views.map((view) => { + // The double only backs the calls the delete path makes on a live task. + const task = new Task(defaultTaskOptions) + Object.defineProperty(task, "taskId", { value: `task-of-${view.viewId}`, writable: true }) + Object.defineProperty(task, "taskApiConfigName", { value: "deleted", writable: true }) + Object.defineProperty(task, "apiConfiguration", { + value: { apiProvider: providerIdentifiers.openrouter, openRouterModelId: "deleted-model" }, + writable: true, + }) + task.setTaskApiConfigName = vi.fn() + task.updateApiConfiguration = vi.fn() + return task + }) + + for (const [index, view] of views.entries()) { + await view.saveViewState("currentApiConfigName", "deleted") + await view.addClineToStack(tasks[index]) + } + + vi.spyOn(deleter["providerSettingsManager"], "deleteConfig").mockResolvedValue(undefined) + vi.spyOn(deleter["providerSettingsManager"], "activateProfile").mockResolvedValue({ + name: "survivor", + id: "survivor-id", + apiProvider: providerIdentifiers.anthropic, + }) + vi.spyOn(deleter["providerSettingsManager"], "getProfile").mockResolvedValue({ + name: "survivor", + id: "survivor-id", + ...survivingSettings, + }) + + await deleter.deleteProviderProfile(profileToDelete) + + // Re-pointing the view is not enough: a task that still names the deleted profile runs on a + // handler built from its settings and keeps it as its sticky profile until it is rebuilt. + for (const task of tasks) { + expect(task.updateApiConfiguration).toHaveBeenCalledWith( + expect.objectContaining({ + apiProvider: providerIdentifiers.anthropic, + apiKey: "survivor-key", + }), + ) + expect(task.setTaskApiConfigName).toHaveBeenCalledWith("survivor") + } + + await deleter.dispose() + await sibling.dispose() + }) }) describe("createTaskWithHistoryItem mode validation", () => { @@ -7293,6 +7424,64 @@ describe("ClineProvider", () => { await provider.dispose() }) + it("should not roll back a shared key that a newer write replaced during a partial setValues", async () => { + const provider = new ClineProvider( + mockContext, + mockOutputChannel, + "sidebar", + new ContextProxy(mockContext), + new WebviewFocusTracker(), + ) + await provider.contextProxy.setValue("mode", "architect") + await provider.contextProxy.setValue("currentApiConfigName", "current-config") + const originalUpdate = mockContext.globalState.update + let rejectConfig: (error: Error) => void = () => {} + mockContext.globalState.update = vi.fn().mockImplementation((key: string) => { + if (key === "currentApiConfigName") { + return new Promise((_, reject) => (rejectConfig = reject)) + } + return Promise.resolve() + }) + + // The mode write commits while the profile-name write is still in flight. + const attempt = provider.setValues({ mode: "code", currentApiConfigName: "other-config" }) + await vi.waitFor(() => expect(provider.getValue("mode")).toBe("code")) + // A newer write for the already committed key lands before the rollback runs. + await provider.setValue("mode", "plan") + rejectConfig(new Error("storage unavailable")) + await expect(attempt).rejects.toThrow("storage unavailable") + + // A rollback may only undo keys that still hold the value this attempt wrote; replaying + // every captured value would clobber the newer write for every view that reads shared state. + expect(provider.getValue("mode")).toBe("plan") + expect(provider.getValue("currentApiConfigName")).toBe("current-config") + + mockContext.globalState.update = originalUpdate + await provider.dispose() + }) + + it("should serve this view's restored mode through getState()", async () => { + const provider = new ClineProvider( + mockContext, + mockOutputChannel, + "sidebar", + new ContextProxy(mockContext), + new WebviewFocusTracker(), + ) + await provider.contextProxy.setValue("mode", "architect") + await provider["setViewStateId"]("mode-view") + // A history or profile restore writes the mode into this view's buffer only; the shared store + // keeps the mode the last committing view chose. + await provider.saveViewState("mode", "code") + + expect(provider.getValue("mode")).toBe("architect") + // getState() is what task creation and getStateToPostToWebview read, so the restored mode has + // to be visible there and not only through getValues(). + expect((await provider.getState()).mode).toBe("code") + + await provider.dispose() + }) + describe("viewId uniqueness", () => { it("should assign unique viewId to each instance", async () => { const provider1 = new ClineProvider( @@ -7411,12 +7600,11 @@ describe("ClineProvider", () => { resolveProfile({ name: "cfg-a", apiProvider: providerIdentifiers.openrouter, openRouterModelId: "model-x" }) await load - // The in-flight selection wins over the loaded state. + // The in-flight selection wins over the loaded state, and cfg-a's settings are not parked + // under cfg-b's name: a name this view changed on its own pins no settings, so reads fall back + // to the shared store until an activation resolves cfg-b together with its configuration. expect(provider["viewLocalState"].currentApiConfigName).toBe("cfg-b") - expect(provider["viewLocalState"].apiConfiguration).toEqual({ - apiProvider: providerIdentifiers.openrouter, - openRouterModelId: "model-x", - }) + expect(provider["viewLocalState"]).not.toHaveProperty("apiConfiguration") expect(provider["viewLocalState"]).not.toHaveProperty("mode") await provider.dispose() }) From f5df1cb8673a654e2689f32b643f6e0b69571ff5 Mon Sep 17 00:00:00 2001 From: Eason Liang <136036952+easonLiangWorldedtech@users.noreply.github.com> Date: Thu, 5 Nov 2026 12:57:41 +0800 Subject: [PATCH 25/42] chore(config): drop the recorded-value state cache now that failed writes read back from the Memento updateGlobalState now corrects the cache from what the Memento reports when a still-current write rejects, which is the policy main shipped, so the per-key record of what storage last accepted has no reader left. git grep over the whole tree found exactly three references to statePersistedCache - the field declaration, the write in initialize() that seeded it from the loaded values, and the write on the success branch of updateGlobalState - and none of them reads it, so all three are gone and the success handler is back to main's `.then(release, ...)`. Behaviour is unchanged: nothing observed the map. Our per-key write generations and getStateWriteGeneration are untouched, and the two generation lines inside updateGlobalState are still the only difference between our method body and main's. Changed executable lines against upstream/main e943530c8 (same script, same base): extension 827 -> 824 in the report below. Gates: prettier --check exit 0; tsc --noEmit exit 0; eslint --max-warnings=0 --no-warn-ignored exit 0; vitest core/config + core/webview = 44 files / 1,290 tests passed, the same counts as before the removal. --- src/core/config/ContextProxy.ts | 5 ----- 1 file changed, 5 deletions(-) diff --git a/src/core/config/ContextProxy.ts b/src/core/config/ContextProxy.ts index 2852ec5453..ad3b1fb3da 100644 --- a/src/core/config/ContextProxy.ts +++ b/src/core/config/ContextProxy.ts @@ -96,11 +96,6 @@ export class ContextProxy { try { // Revert to original assignment this.stateCache[key] = this.originalContext.globalState.get(key) - // Storage is the baseline of the rollback path: without this entry, a failed write - // on a key that has never been written through this proxy falls back to the - // previous cached value - which an overlapping write may have made its own - // unpersisted one. - this.statePersistedCache.set(key, this.stateCache[key]) } catch (error) { logger.error(`Error loading global ${key}: ${error instanceof Error ? error.message : String(error)}`) } From 555dbc2ea715e1d48dea3a5b96b7d4a901afc5e2 Mon Sep 17 00:00:00 2001 From: Eason Liang <136036952+easonLiangWorldedtech@users.noreply.github.com> Date: Thu, 5 Nov 2026 13:21:01 +0800 Subject: [PATCH 26/42] test(webview): re-adopt main's ten ClineProvider spec cases onto the split harness The merge e943530c8 left ten titles in src/core/webview/__tests__/ClineProvider.spec.ts without survivors in our tree - all in-base, all absent on our pre-merge parent 9819b5f92, none elsewhere in the tree, and every production symbol they exercise still present. They are test-only, so they are ported here rather than answered in writing. Ported verbatim from e943530c8^2 into the same describes. What our rewrite had done to each case, by title: Deleted outright (the distinctive fixture literals survived only inside the file-level vi.mock factories; the assertions did not) - re-adopted here: validates and falls back to default mode when restored mode no longer exists preserves mode when it exists in custom modes (only main's negative case remained, in our 'should not restore a persisted mode whose custom mode was deleted') preserves mode when it exists in built-in modes handles history items without mode property continues with task restoration even if mode config loading fails updates every zoo-gateway profile and activates only the active one (the update-all and activate-only probes were gone; our 'creates a Zoo Gateway profile when none exists' covers neither) skips seeding when every zoo-gateway profile already has the current token and base URL re-seeds when any zoo-gateway profile has a stale or missing token re-seeds when any zoo-gateway profile has a stale base URL (our describe kept only main's first seeding case, byte-identical) createTaskWithHistoryItem mode validation - the grouping describe itself Reworded to the observable this tree ships - expected values and intent unchanged (4 of the 10, all four listed above as deleted first): - the three mode cases asserted globalState.update("mode", ). This branch persists the restored mode through the view's own pin (ClineProvider.ts:1998 saveViewState, and the comment above it says why a global write is wrong in parallel mode), so each case now asserts update("viewStates", ...) plus viewLocalState.mode === and keeps main's getCustomModes / getModeBySlug / log-fallback / historyItem.mode assertions untouched. Nothing was dropped or loosened: the same value is pinned, for this view. - the gateway case asserted saveConfig("Backup Zoo", objectContaining(token, baseUrl)). This branch refreshes every zoo-gateway profile through upsertProviderProfile so that a view pinned to a profile re-resolves it (ClineProvider.ts:3393-3407), so the case now asserts the second upsert call carrying activate:false and that saveConfig was not called at all. The title's 'activates only the active one' is asserted, not implied. Harness-only edits inside the ported blocks: the readonly member swaps go through one declared structural type (MemberSwapTarget) instead of 'as any', and mock payloads use as never, so this file's no-explicit-any suppression count did not rise. Verification: prettier --check clean; tsc --noEmit -p . clean; eslint --max-warnings=0 clean (0 errors) on the spec plus ClineProvider.ts, ContextProxy.ts and ContextProxy.spec .ts; vitest run core/config core/webview --no-file-parallelism = 44 files / 1299 tests passed (1290 before, +9 ported cases). Staged explicitly: only src/core/webview/__tests__/ClineProvider.spec.ts (+424 -5). Measured with the same script and base as the other heads: PACKAGE extension still 810 changed executable lines, so this head adds 0 executable lines (spec paths never count against the 500-line gate). --- .../webview/__tests__/ClineProvider.spec.ts | 429 +++++++++++++++++- 1 file changed, 424 insertions(+), 5 deletions(-) diff --git a/src/core/webview/__tests__/ClineProvider.spec.ts b/src/core/webview/__tests__/ClineProvider.spec.ts index adce1fadab..c41df20bff 100644 --- a/src/core/webview/__tests__/ClineProvider.spec.ts +++ b/src/core/webview/__tests__/ClineProvider.spec.ts @@ -39,6 +39,11 @@ import { safeWriteJson } from "../../../utils/safeWriteJson" import { t } from "../../../i18n" import { ClineProvider } from "../ClineProvider" + +// The re-adopted cases below swap ClineProvider's readonly members for test doubles. A readonly +// property can only be re-bound through a structural view, so the shape is declared once here +// instead of repeating a double assertion at every stub site (AGENTS.md: no new any casts). +type MemberSwapTarget = { customModesManager: unknown; providerSettingsManager: unknown } import { webviewMessageHandler } from "../webviewMessageHandler" import { Terminal } from "../../../integrations/terminal/Terminal" import { MessageManager } from "../../message-manager" @@ -608,7 +613,7 @@ describe("ClineProvider", () => { updateGlobalStateSpy = vi.spyOn(provider.contextProxy, "setValue") // @ts-ignore - Accessing private property for testing. - provider.customModesManager = mockCustomModesManager + ;(provider as MemberSwapTarget).customModesManager = mockCustomModesManager // Mock getMcpHub method for generateSystemPrompt provider.getMcpHub = vi.fn().mockReturnValue({ @@ -5612,6 +5617,289 @@ describe("ClineProvider", () => { }) }) + describe("createTaskWithHistoryItem mode validation", () => { + test("validates and falls back to default mode when restored mode no longer exists", async () => { + await provider.resolveWebviewView(mockWebviewView) + + // Mock custom modes that don't include the saved mode + const mockCustomModesManager = { + getCustomModes: vi.fn().mockResolvedValue([ + { + slug: "existing-mode", + name: "Existing Mode", + roleDefinition: "Test role", + groups: ["read"] as const, + }, + ]), + dispose: vi.fn(), + } + ;(provider as MemberSwapTarget).customModesManager = mockCustomModesManager + + // Mock getModeBySlug to return undefined for non-existent mode + const { getModeBySlug } = await import("../../../shared/modes") + vi.mocked(getModeBySlug) + .mockReturnValueOnce(undefined) // First call returns undefined (mode doesn't exist) + .mockReturnValue({ + slug: "code", + name: "Code Mode", + roleDefinition: "You are a code assistant", + groups: ["read", "edit"], + }) // Subsequent calls return default mode + + // Mock provider settings manager + ;(provider as MemberSwapTarget).providerSettingsManager = { + getModeConfigId: vi.fn().mockResolvedValue(undefined), + listConfig: vi.fn().mockResolvedValue([]), + } + + // Spy on log method to verify warning was logged + const logSpy = vi.spyOn(provider, "log") + + // Create history item with non-existent mode + const historyItem = { + id: "test-id", + ts: Date.now(), + task: "Test task", + mode: "non-existent-mode", // This mode doesn't exist + number: 1, + tokensIn: 0, + tokensOut: 0, + totalCost: 0, + } + + // Initialize with history item + await provider.createTaskWithHistoryItem(historyItem) + + // Verify mode validation occurred + expect(mockCustomModesManager.getCustomModes).toHaveBeenCalled() + expect(getModeBySlug).toHaveBeenCalledWith("non-existent-mode", expect.any(Array)) + + // Verify fallback to default mode + expect(mockContext.globalState.update).toHaveBeenCalledWith("viewStates", expect.anything()) + // This branch persists the restored mode through the view's own pin rather than the shared + // global write main asserted on, because a global write would leak the restored mode into + // other views in parallel mode. Same claim, moved observable: the resolved mode is what + // this view now holds, and historyItem still carries it below. + expect(provider["viewLocalState"].mode).toBe("code") + expect(logSpy).toHaveBeenCalledWith( + "Mode 'non-existent-mode' from history no longer exists. Falling back to default mode 'code'.", + ) + + // Verify history item was updated with default mode + expect(historyItem.mode).toBe("code") + }) + + test("preserves mode when it exists in custom modes", async () => { + await provider.resolveWebviewView(mockWebviewView) + + // Mock custom modes that include the saved mode + const mockCustomModesManager = { + getCustomModes: vi.fn().mockResolvedValue([ + { + slug: "custom-mode", + name: "Custom Mode", + roleDefinition: "Custom role", + groups: ["read", "edit"] as const, + }, + ]), + dispose: vi.fn(), + } + ;(provider as MemberSwapTarget).customModesManager = mockCustomModesManager + + // Mock getModeBySlug to return the custom mode + const { getModeBySlug } = await import("../../../shared/modes") + vi.mocked(getModeBySlug).mockReturnValue({ + slug: "custom-mode", + name: "Custom Mode", + roleDefinition: "Custom role", + groups: ["read", "edit"], + }) + + // Mock provider settings manager + ;(provider as MemberSwapTarget).providerSettingsManager = { + getModeConfigId: vi.fn().mockResolvedValue("config-id"), + listConfig: vi + .fn() + .mockResolvedValue([ + { name: "test-config", id: "config-id", apiProvider: providerIdentifiers.anthropic }, + ]), + activateProfile: vi.fn().mockResolvedValue({ + name: "test-config", + id: "config-id", + apiProvider: providerIdentifiers.anthropic, + }), + } + + // Spy on log method to verify no warning was logged + const logSpy = vi.spyOn(provider, "log") + + // Create history item with existing custom mode + const historyItem = { + id: "test-id", + ts: Date.now(), + task: "Test task", + mode: "custom-mode", + number: 1, + tokensIn: 0, + tokensOut: 0, + totalCost: 0, + } + + // Initialize with history item + await provider.createTaskWithHistoryItem(historyItem) + + // Verify mode validation occurred + expect(mockCustomModesManager.getCustomModes).toHaveBeenCalled() + expect(getModeBySlug).toHaveBeenCalledWith("custom-mode", expect.any(Array)) + + // Verify mode was preserved + expect(mockContext.globalState.update).toHaveBeenCalledWith("viewStates", expect.anything()) + // This branch persists the restored mode through the view's own pin rather than the shared + // global write main asserted on, because a global write would leak the restored mode into + // other views in parallel mode. Same claim, moved observable: the resolved mode is what + // this view now holds, and historyItem still carries it below. + expect(provider["viewLocalState"].mode).toBe("custom-mode") + expect(logSpy).not.toHaveBeenCalledWith(expect.stringContaining("no longer exists")) + + // Verify history item mode was not changed + expect(historyItem.mode).toBe("custom-mode") + }) + + test("preserves mode when it exists in built-in modes", async () => { + await provider.resolveWebviewView(mockWebviewView) + + // Mock no custom modes + const mockCustomModesManager = { + getCustomModes: vi.fn().mockResolvedValue([]), + dispose: vi.fn(), + } + ;(provider as MemberSwapTarget).customModesManager = mockCustomModesManager + + // Mock getModeBySlug to return built-in architect mode + const { getModeBySlug } = await import("../../../shared/modes") + vi.mocked(getModeBySlug).mockReturnValue({ + slug: "architect", + name: "Architect Mode", + roleDefinition: "You are an architect", + groups: ["read", "edit"], + }) + + // Mock provider settings manager + ;(provider as MemberSwapTarget).providerSettingsManager = { + getModeConfigId: vi.fn().mockResolvedValue(undefined), + listConfig: vi.fn().mockResolvedValue([]), + } + + // Create history item with built-in mode + const historyItem = { + id: "test-id", + ts: Date.now(), + task: "Test task", + mode: "architect", + number: 1, + tokensIn: 0, + tokensOut: 0, + totalCost: 0, + } + + // Initialize with history item + await provider.createTaskWithHistoryItem(historyItem) + + // Verify mode was preserved + expect(mockContext.globalState.update).toHaveBeenCalledWith("viewStates", expect.anything()) + // This branch persists the restored mode through the view's own pin rather than the shared + // global write main asserted on, because a global write would leak the restored mode into + // other views in parallel mode. Same claim, moved observable: the resolved mode is what + // this view now holds, and historyItem still carries it below. + expect(provider["viewLocalState"].mode).toBe("architect") + + // Verify history item mode was not changed + expect(historyItem.mode).toBe("architect") + }) + + test("handles history items without mode property", async () => { + await provider.resolveWebviewView(mockWebviewView) + + // Mock provider settings manager + ;(provider as MemberSwapTarget).providerSettingsManager = { + getModeConfigId: vi.fn().mockResolvedValue(undefined), + listConfig: vi.fn().mockResolvedValue([]), + } + + // Create history item without mode + const historyItem = { + id: "test-id", + ts: Date.now(), + task: "Test task", + // No mode property + number: 1, + tokensIn: 0, + tokensOut: 0, + totalCost: 0, + } + + // Initialize with history item + await provider.createTaskWithHistoryItem(historyItem) + + // Verify no mode validation occurred (mode update not called) + expect(mockContext.globalState.update).not.toHaveBeenCalledWith("mode", expect.any(String)) + }) + + test("continues with task restoration even if mode config loading fails", async () => { + await provider.resolveWebviewView(mockWebviewView) + + // Mock custom modes + const mockCustomModesManager = { + getCustomModes: vi.fn().mockResolvedValue([]), + dispose: vi.fn(), + } + ;(provider as MemberSwapTarget).customModesManager = mockCustomModesManager + + // Mock getModeBySlug to return built-in mode + const { getModeBySlug } = await import("../../../shared/modes") + vi.mocked(getModeBySlug).mockReturnValue({ + slug: "code", + name: "Code Mode", + roleDefinition: "You are a code assistant", + groups: ["read", "edit"], + }) + + // Mock provider settings manager to throw error + ;(provider as MemberSwapTarget).providerSettingsManager = { + getModeConfigId: vi.fn().mockResolvedValue("config-id"), + listConfig: vi + .fn() + .mockResolvedValue([ + { name: "test-config", id: "config-id", apiProvider: providerIdentifiers.anthropic }, + ]), + activateProfile: vi.fn().mockRejectedValue(new Error("Failed to load config")), + } + + // Spy on log method + const logSpy = vi.spyOn(provider, "log") + + // Create history item + const historyItem = { + id: "test-id", + ts: Date.now(), + task: "Test task", + mode: "code", + number: 1, + tokensIn: 0, + tokensOut: 0, + totalCost: 0, + } + + // Initialize with history item - should not throw + await expect(provider.createTaskWithHistoryItem(historyItem)).resolves.not.toThrow() + + // Verify error was logged but task restoration continued + expect(logSpy).toHaveBeenCalledWith( + expect.stringContaining("Failed to restore API configuration for mode 'code'"), + ) + }) + }) + describe("deleteProviderProfile", () => { it("moves the settings manager's current profile to the survivor when the active profile is deleted", async () => { const contextProxy = new ContextProxy(mockContext) @@ -6748,7 +7036,10 @@ describe("ClineProvider", () => { ) const logSpy = vi.spyOn(provider, "log") // @ts-ignore - Replace customModesManager with a test double (no custom modes). - provider.customModesManager = { getCustomModes: vi.fn().mockResolvedValue([]), dispose: vi.fn() } + ;(provider as MemberSwapTarget).customModesManager = { + getCustomModes: vi.fn().mockResolvedValue([]), + dispose: vi.fn(), + } // The file-level modes mock resolves every slug to a mode; drop the pinned slug. const modesModule = vi.mocked(await import("../../../shared/modes")) const originalMode = modesModule.getModeBySlug("code") @@ -6780,7 +7071,10 @@ describe("ClineProvider", () => { ) const { getProfile: getProfileSpy, resolveProfile } = stallProviderSettingsProfile(provider) // @ts-ignore - Replace customModesManager with a test double (no custom modes). - provider.customModesManager = { getCustomModes: vi.fn().mockResolvedValue([]), dispose: vi.fn() } + ;(provider as MemberSwapTarget).customModesManager = { + getCustomModes: vi.fn().mockResolvedValue([]), + dispose: vi.fn(), + } await provider.saveViewState("mode", "code") await provider.saveViewState("currentApiConfigName", "cfg-a") const load = provider["setViewStateId"]("stable-sidebar-view") @@ -7239,7 +7533,10 @@ describe("ClineProvider", () => { ) const logSpy = vi.spyOn(provider, "log") // @ts-ignore - Replace customModesManager with a test double (no custom modes). - provider.customModesManager = { getCustomModes: vi.fn().mockResolvedValue([]), dispose: vi.fn() } + ;(provider as MemberSwapTarget).customModesManager = { + getCustomModes: vi.fn().mockResolvedValue([]), + dispose: vi.fn(), + } // The file-level modes mock resolves every slug to a mode; narrow it to the slugs under test. const modesModule = vi.mocked(await import("../../../shared/modes")) const originalMode = modesModule.getModeBySlug("code") @@ -7315,7 +7612,10 @@ describe("ClineProvider", () => { ) vi.spyOn(provider, "postStateToWebview").mockResolvedValue(undefined) // @ts-ignore - Replace customModesManager with a test double (the real reset writes to disk). - provider.customModesManager = { resetCustomModes: vi.fn().mockResolvedValue(undefined), dispose: vi.fn() } + ;(provider as MemberSwapTarget).customModesManager = { + resetCustomModes: vi.fn().mockResolvedValue(undefined), + dispose: vi.fn(), + } // The modal answer is a string label; the last-typed vscode overload expects a // MessageItem. A double assertion is the last-resort cast here (AGENTS.md): the // production path compares the answer against the string label directly, so the @@ -10083,6 +10383,64 @@ describe("ClineProvider - Comprehensive Edit/Delete Edge Cases", () => { // State must still be refreshed even when profile persistence fails. expect(provider.postStateToWebview).toHaveBeenCalled() }) + it("updates every zoo-gateway profile and activates only the active one", async () => { + vi.spyOn(provider, "getState").mockResolvedValue({ + apiConfiguration: { zooGatewayModelId: "anthropic/claude-sonnet-4" }, + } as never) + vi.spyOn(provider.contextProxy, "getProviderSettings").mockReturnValue({ + apiProvider: providerIdentifiers.zooGateway, + } as never) + vi.spyOn(provider.contextProxy, "getValues").mockReturnValue({ + currentApiConfigName: "Zoo Gateway", + } as never) + const upsertSpy = vi.spyOn(provider, "upsertProviderProfile").mockResolvedValue("profile-id") + const saveConfig = vi.fn().mockResolvedValue(undefined) + vi.spyOn(provider, "postStateToWebview").mockResolvedValue(undefined) + ;(provider as MemberSwapTarget).providerSettingsManager = { + listConfig: vi.fn().mockResolvedValue([ + { name: "Zoo Gateway", apiProvider: providerIdentifiers.zooGateway }, + { name: "Backup Zoo", apiProvider: providerIdentifiers.zooGateway }, + ]), + getProfile: vi + .fn() + .mockResolvedValueOnce({ + apiProvider: providerIdentifiers.zooGateway, + zooSessionToken: "old-token", + zooGatewayBaseUrl: "https://old.example/api/gateway/v1", + }) + .mockResolvedValueOnce({ + apiProvider: providerIdentifiers.zooGateway, + zooSessionToken: "old-token", + }), + saveConfig, + } + + await provider.handleZooCodeCallback("new-token") + + expect(upsertSpy).toHaveBeenCalledWith( + "Zoo Gateway", + expect.objectContaining({ + zooSessionToken: "new-token", + zooGatewayBaseUrl: "https://www.zoocode.dev/api/gateway/v1", + }), + true, + ) + // Both zoo-gateway profiles are refreshed - that is what every profile means - and this branch + // does it through upsertProviderProfile rather than a direct saveConfig so that a view pinned + // to a profile re-resolves it instead of serving the pre-callback config. The activation flag + // follows whether Zoo Gateway is already the active provider: this callback keeps Zoo Gateway + // active and refreshes the other profiles without activating them, so activates only the + // active one holds through the API we ship. + expect(upsertSpy).toHaveBeenCalledWith( + "Backup Zoo", + expect.objectContaining({ + zooSessionToken: "new-token", + zooGatewayBaseUrl: "https://www.zoocode.dev/api/gateway/v1", + }), + false, + ) + expect(saveConfig).not.toHaveBeenCalled() + }) }) describe("ensureZooGatewayProfileSeeded", () => { @@ -10097,6 +10455,67 @@ describe("ClineProvider - Comprehensive Edit/Delete Edge Cases", () => { expect(handleSpy).not.toHaveBeenCalled() }) + it("skips seeding when every zoo-gateway profile already has the current token and base URL", async () => { + const { getCachedZooCodeToken } = await import("../../../services/zoo-code-auth") + vi.mocked(getCachedZooCodeToken).mockReturnValue("current-token") + const handleSpy = vi.spyOn(provider, "handleZooCodeCallback").mockResolvedValue(undefined) + const postMessageSpy = vi.spyOn(provider, "postMessageToWebview").mockResolvedValue(undefined) + + ;(provider as MemberSwapTarget).providerSettingsManager = { + listConfig: vi + .fn() + .mockResolvedValue([{ name: "Zoo Gateway", apiProvider: providerIdentifiers.zooGateway }]), + getProfile: vi.fn().mockResolvedValue({ + zooSessionToken: "current-token", + zooGatewayBaseUrl: "https://www.zoocode.dev/api/gateway/v1", + }), + } + + await provider["ensureZooGatewayProfileSeeded"]() + + expect(handleSpy).not.toHaveBeenCalled() + expect(postMessageSpy).toHaveBeenCalledWith({ type: "zooGatewayCredentialsReady" }) + }) + + it("re-seeds when any zoo-gateway profile has a stale or missing token", async () => { + const { getCachedZooCodeToken } = await import("../../../services/zoo-code-auth") + vi.mocked(getCachedZooCodeToken).mockReturnValue("fresh-token") + const handleSpy = vi.spyOn(provider, "handleZooCodeCallback").mockResolvedValue(undefined) + + ;(provider as MemberSwapTarget).providerSettingsManager = { + listConfig: vi + .fn() + .mockResolvedValue([{ name: "Zoo Gateway", apiProvider: providerIdentifiers.zooGateway }]), + getProfile: vi.fn().mockResolvedValue({ + zooSessionToken: "stale-token", + zooGatewayBaseUrl: "https://www.zoocode.dev/api/gateway/v1", + }), + } + + await provider["ensureZooGatewayProfileSeeded"]() + + expect(handleSpy).toHaveBeenCalledWith("fresh-token") + }) + + it("re-seeds when any zoo-gateway profile has a stale base URL", async () => { + const { getCachedZooCodeToken } = await import("../../../services/zoo-code-auth") + vi.mocked(getCachedZooCodeToken).mockReturnValue("current-token") + const handleSpy = vi.spyOn(provider, "handleZooCodeCallback").mockResolvedValue(undefined) + + ;(provider as MemberSwapTarget).providerSettingsManager = { + listConfig: vi + .fn() + .mockResolvedValue([{ name: "Zoo Gateway", apiProvider: providerIdentifiers.zooGateway }]), + getProfile: vi.fn().mockResolvedValue({ + zooSessionToken: "current-token", + zooGatewayBaseUrl: "https://staging.zoocode.dev/api/gateway/v1", + }), + } + + await provider["ensureZooGatewayProfileSeeded"]() + + expect(handleSpy).toHaveBeenCalledWith("current-token") + }) }) }) }) From 3208e13acc2b08e396020eb9552223e632dafb42 Mon Sep 17 00:00:00 2001 From: Eason Liang <136036952+easonLiangWorldedtech@users.noreply.github.com> Date: Thu, 5 Nov 2026 13:51:13 +0800 Subject: [PATCH 27/42] test(webview): drop the three duplicated top-level cases, name the second describe The review thread measured true against bf7a9e92e. Three cases appeared twice, identical apart from indentation - "should merge concurrent persisted updates from separate provider instances without lost viewStates", "should remove the buffered apiConfiguration when it is cleared" and "should increment instance count for each new instance" each sat once inside a describe and once as a direct child of describe("ClineProvider") - and describe("view state persistence edge cases") appeared twice, so reports showed two groups under one name. Deleted the three top-level copies; the in-describe copies stay byte-for-byte unchanged. Renamed the second block to "view-local buffer: loading, setValue mutations and rollback", which names what its four cases actually do: load the persisted mode, profile name and resolved profile into viewLocalState; apply setValue mutations to global state and keep or clear the buffered fields; drop the buffered apiConfiguration when it is cleared; roll back the shared write when per-view persistence fails. The first block keeps the old title - its eleven cases are all persisted-viewStates edge cases, which is what it says. Survivor check before pushing: 349 test titles in the file before, 346 after; each of the three names still appears exactly once and no title dropped to zero. Three other same-title pairs exist ("handles case when no current task exists", "loads saved API config when switching modes", "saves current config when switching to mode without config") and are left alone: their bodies differ, so they are not duplicates of each other. prettier --check, tsc --noEmit -p . and eslint --max-warnings=0 are clean, and vitest core/webview is 34 files / 982 tests green. No production file is touched, so the scope measure still reports the same 810 extension-package executable lines. --- .../webview/__tests__/ClineProvider.spec.ts | 81 +------------------ 1 file changed, 1 insertion(+), 80 deletions(-) diff --git a/src/core/webview/__tests__/ClineProvider.spec.ts b/src/core/webview/__tests__/ClineProvider.spec.ts index c41df20bff..b47ae093bf 100644 --- a/src/core/webview/__tests__/ClineProvider.spec.ts +++ b/src/core/webview/__tests__/ClineProvider.spec.ts @@ -7371,41 +7371,7 @@ describe("ClineProvider", () => { }) }) - it("should merge concurrent persisted updates from separate provider instances without lost viewStates", async () => { - const provider1 = new ClineProvider( - mockContext, - mockOutputChannel, - "sidebar", - new ContextProxy(mockContext), - - new WebviewFocusTracker(), - ) - const provider2 = new ClineProvider( - mockContext, - mockOutputChannel, - "editor", - new ContextProxy(mockContext), - new WebviewFocusTracker(), - ) - - await provider1["setViewStateId"]("stable-sidebar-view") - await provider2["setViewStateId"]("stable-editor-view") - - await Promise.all([ - provider1.saveViewState("mode", "architect"), - provider2.saveViewState("currentApiConfigName", "editor-profile"), - ]) - - expect(mockContext.globalState.get("viewStates")).toMatchObject({ - "stable-sidebar-view": { mode: "architect" }, - "stable-editor-view": { currentApiConfigName: "editor-profile" }, - }) - - await provider1.dispose() - await provider2.dispose() - }) - - describe("view state persistence edge cases", () => { + describe("view-local buffer: loading, setValue mutations and rollback", () => { it("should load persisted mode, profile name and resolved profile into viewLocalState", async () => { const writer = new ClineProvider( mockContext, @@ -7584,24 +7550,6 @@ describe("ClineProvider", () => { await provider.dispose() }) - it("should remove the buffered apiConfiguration when it is cleared", async () => { - const provider = new ClineProvider( - mockContext, - mockOutputChannel, - "sidebar", - new ContextProxy(mockContext), - new WebviewFocusTracker(), - ) - const save = provider.saveViewState.bind(provider) as (key: string, value: unknown) => Promise - await provider.saveViewState("apiConfiguration", { apiProvider: providerIdentifiers.openrouter }) - await provider.saveViewState("apiConfiguration", undefined) - expect(provider["viewLocalState"]).not.toHaveProperty("apiConfiguration") - await provider.saveViewState("apiConfiguration", { apiProvider: providerIdentifiers.openrouter }) - await save("apiConfiguration", null) - expect(provider["viewLocalState"]).not.toHaveProperty("apiConfiguration") - await provider.dispose() - }) - it("should clear viewLocalState and the persisted entry when resetting state", async () => { const provider = new ClineProvider( mockContext, @@ -7851,33 +7799,6 @@ describe("ClineProvider", () => { }) }) - it("should increment instance count for each new instance", async () => { - const provider1 = new ClineProvider( - mockContext, - mockOutputChannel, - "editor", - new ContextProxy(mockContext), - new WebviewFocusTracker(), - ) - const provider2 = new ClineProvider( - mockContext, - mockOutputChannel, - "editor", - new ContextProxy(mockContext), - new WebviewFocusTracker(), - ) - - // First editor instance should be "editor-0" (or next available) - // Second editor instance should have a different number - const num1 = parseInt(provider1.viewId.split("-")[1]!) - const num2 = parseInt(provider2.viewId.split("-")[1]!) - - expect(num2).toBeGreaterThan(num1) - - await provider1.dispose() - await provider2.dispose() - }) - it("should reapply an independently mutated profile name when the load settles", async () => { const provider = new ClineProvider( mockContext, From 5e4d985f3285b2ec1af82e29193eabb88d1a1af0 Mon Sep 17 00:00:00 2001 From: Eason Liang <136036952+easonLiangWorldedtech@users.noreply.github.com> Date: Thu, 5 Nov 2026 13:58:51 +0800 Subject: [PATCH 28/42] test(webview): pin zoo-gateway seeding to every-profile semantics The review thread on the seeding suite measured true against 45795c8cc: every seeding case put a single zoo-gateway profile in the store, where a first-only check, a last-only check, an every-profile check and the shipped any-profile guard all take the same branch, and the case titled "...stale or missing token" never left zooSessionToken unset. Added three cases, with the production guard untouched. Two run through it.each over a store of ["Zoo Gateway", "Other", "Zoo Gateway 2"] where "Other" is an anthropic profile: one with the stale profile last, one with it first; each asserts handleZooCodeCallback ran with the fresh token and that getProfile was never asked about "Other", which is what exercises the apiProvider filter. The third gives a zoo-gateway profile with a current base URL and no token at all, and asserts seeding still runs. Controls, each applied to src/core/webview/ClineProvider.ts, measured, then reverted (the file's blob is ee8203a4d2 before and after, and git checkout HEAD -- confirmed it): zooGatewayProfiles.slice(0, 1) fails the stale-last case; .slice(-1) fails the stale-first case; replacing the apiProvider filter with () => true fails the "Other" assertion in the stale-last row; requiring a non-null token before comparing fails the no-token case. Every mutation kills exactly one test and nothing else. vitest core/webview + core/config: 44 files / 1299 tests green (1296 before this commit, plus the three new cases). prettier --check, tsc --noEmit -p . and eslint --max-warnings=0 are clean; scope unchanged at 810 extension-package executable lines (no production change). --- .../webview/__tests__/ClineProvider.spec.ts | 67 +++++++++++++++++++ 1 file changed, 67 insertions(+) diff --git a/src/core/webview/__tests__/ClineProvider.spec.ts b/src/core/webview/__tests__/ClineProvider.spec.ts index b47ae093bf..7bb1909905 100644 --- a/src/core/webview/__tests__/ClineProvider.spec.ts +++ b/src/core/webview/__tests__/ClineProvider.spec.ts @@ -10437,6 +10437,73 @@ describe("ClineProvider - Comprehensive Edit/Delete Edge Cases", () => { expect(handleSpy).toHaveBeenCalledWith("current-token") }) + // The up-to-date guard reads every zoo-gateway profile rather than one end of the list, and it + // skips profiles that belong to another provider. With a single profile in the store a + // first-only, a last-only and an every-profile check all behave the same, so the order of the + // two rows below is what pins the guard down. + it.each([ + { + title: "re-seeds when a later zoo-gateway profile is stale and the first is current", + profiles: ["Zoo Gateway", "Other", "Zoo Gateway 2"], + staleProfile: "Zoo Gateway 2", + }, + { + title: "re-seeds when the first zoo-gateway profile is stale and the last is current", + profiles: ["Zoo Gateway", "Other", "Zoo Gateway 2"], + staleProfile: "Zoo Gateway", + }, + ])("$title", async ({ profiles, staleProfile }) => { + const { getCachedZooCodeToken } = await import("../../../services/zoo-code-auth") + vi.mocked(getCachedZooCodeToken).mockReturnValue("fresh-token") + const handleSpy = vi.spyOn(provider, "handleZooCodeCallback").mockResolvedValue(undefined) + const getProfile = vi.fn().mockImplementation(({ name }: { name: string }) => + // Name-keyed so the non-gateway profile reads as up to date: the only way this test + // fails on that profile is if the provider filter stops ignoring it. + name === staleProfile + ? { + zooSessionToken: "stale-token", + zooGatewayBaseUrl: "https://www.zoocode.dev/api/gateway/v1", + } + : { + zooSessionToken: "fresh-token", + zooGatewayBaseUrl: "https://www.zoocode.dev/api/gateway/v1", + }, + ) + ;(provider as MemberSwapTarget).providerSettingsManager = { + listConfig: vi.fn().mockResolvedValue( + profiles.map((name) => ({ + name, + apiProvider: + name === "Other" ? providerIdentifiers.anthropic : providerIdentifiers.zooGateway, + })), + ), + getProfile, + } + + await provider["ensureZooGatewayProfileSeeded"]() + + expect(handleSpy).toHaveBeenCalledWith("fresh-token") + expect(getProfile.mock.calls.map(([arg]) => arg.name)).not.toContain("Other") + }) + + it("re-seeds when a zoo-gateway profile carries no token at all", async () => { + const { getCachedZooCodeToken } = await import("../../../services/zoo-code-auth") + vi.mocked(getCachedZooCodeToken).mockReturnValue("fresh-token") + const handleSpy = vi.spyOn(provider, "handleZooCodeCallback").mockResolvedValue(undefined) + ;(provider as MemberSwapTarget).providerSettingsManager = { + listConfig: vi + .fn() + .mockResolvedValue([{ name: "Zoo Gateway", apiProvider: providerIdentifiers.zooGateway }]), + // An imported or half-written profile: the base URL is right, the token is absent. + getProfile: vi + .fn() + .mockResolvedValue({ zooGatewayBaseUrl: "https://www.zoocode.dev/api/gateway/v1" }), + } + + await provider["ensureZooGatewayProfileSeeded"]() + + expect(handleSpy).toHaveBeenCalledWith("fresh-token") + }) }) }) }) From bfea0a875292e76bab1086f90980a7a6f4642bb9 Mon Sep 17 00:00:00 2001 From: Eason Liang <136036952+easonLiangWorldedtech@users.noreply.github.com> Date: Thu, 5 Nov 2026 14:45:27 +0800 Subject: [PATCH 29/42] fix(webview): refresh pinned siblings and their tasks on a non-activating profile save The activating branch refreshed sibling views inline; the non-activating branch checked only this.pinnedProfileName, so a save that did not activate left every other live view pinned to that profile serving its buffered copy of the old settings, and left any task following the profile with the handler built from them. That branch is load-bearing: handleZooCodeCallback routes non-active Zoo Gateway profile updates through it. refreshSiblingsAfterProfileSave is ported unchanged from the n4 head (877ea0a00) rather than invented a third time: one overlay loop over the instances pinned to the saved name, then a separate task loop. The separation is itself the second half of the fix - the inline copy on this head nested the task rebuild under the same pinned-name check, so a task restored from history that follows profile A inside a view pinning profile B was never rebuilt. Both save branches now call the one helper. ClineProvider.ts 6442 -> 6456 lines. Tests. The existing sibling case drove activate=true while its comment described the false branch, so it is renamed to say "pinned to the activated profile" and its comment corrected. Two cases arrive with the capability: the same save with activate=false, asserting the pinned sibling's buffered overlay moves to the saved settings; and a sibling whose task follows the saved profile while its view pins another, asserting the handler rebuild still happens. Both fail against 723c363c6 (expected undefined to deeply equal { apiProvider: 'anthropic', ...1 }; expected "vi.fn()" to be called with arguments [ ...2 ]). Controls (ClineProvider.ts snapshotted at ff22c45943, restored by content hash after each): drop the non-activating call -> the overlay and task cases fail, the activating case passes; drop the activating call -> only the activating case fails; nest the task rebuild back under the pinned-name check (the shape this head had) -> only the task case fails; delete the helper's overlay write -> both overlay cases fail. Gates: prettier --check clean; tsc --noEmit -p . clean; eslint --max-warnings=0 clean on both files; vitest core/webview + core/config 44 files / 1301 tests green (1299 before, +2 cases). Scope 810 -> 815 extension-package executable lines (types unchanged at 8). --- src/core/webview/ClineProvider.ts | 58 ++++++++----- .../webview/__tests__/ClineProvider.spec.ts | 81 ++++++++++++++++++- 2 files changed, 114 insertions(+), 25 deletions(-) diff --git a/src/core/webview/ClineProvider.ts b/src/core/webview/ClineProvider.ts index aed20a89ba..1dde5a54a3 100644 --- a/src/core/webview/ClineProvider.ts +++ b/src/core/webview/ClineProvider.ts @@ -3049,26 +3049,9 @@ export class ClineProvider if (signal.aborted) return id - // Refresh other live views pinned to this profile so their buffered overlay cannot - // keep serving the pre-save settings under the same profile name. - for (const instance of ClineProvider.getAllInstances()) { - if (instance === this || instance._disposed || instance.pinnedProfileName !== name) { - continue - } - // Direct private access: compile-time safe across sibling instances. - await instance._saveViewLocalStateFromMutation({ apiConfiguration: providerSettings }) - - // A sibling task running under this profile holds a handler built from the old - // settings: rebuild it so the conversation does not keep sending the old token. - if (instance.getCurrentTask()?.taskApiConfigName === name) { - const { - name: _recordName, - id: _recordId, - ...taskSettings - } = providerSettings as ProviderSettings & { name?: string; id?: string } - instance.updateTaskApiHandlerIfNeeded(taskSettings, { forceRebuild: true }) - } - } + // Refresh every other live view pinned to this profile, and rebuild the tasks that + // follow it, so no sibling keeps serving the pre-save settings under the same name. + await this.refreshSiblingsAfterProfileSave(name, providerSettings) // Change the provider for the current task. // TODO: We should rename `buildApiHandler` for clarity (e.g. `getProviderClient`). @@ -3079,8 +3062,8 @@ export class ClineProvider } else { await this.updateGlobalState("listApiConfigMeta", await this.providerSettingsManager.listConfig()) - // A non-activating save still changes the profile's settings: refresh the views - // that buffered a copy, or their getState() keeps the pre-save values. + // A non-activating save still changes the profile's settings: refresh this view when it + // pins the saved profile; its siblings are refreshed by the helper below. if (this.pinnedProfileName === name) { await this._saveViewLocalStateFromMutation({ apiConfiguration: providerSettings }) // Only rebuild a task that actually runs under the saved profile. @@ -3088,6 +3071,10 @@ export class ClineProvider this.updateTaskApiHandlerIfNeeded(providerSettings, { forceRebuild: true }) } } + // A non-activating save changes the profile's settings too: refresh every sibling + // that buffered a copy (pinned siblings included) and rebuild the tasks that follow the + // profile. This branch had no sibling refresh at all before this change. + await this.refreshSiblingsAfterProfileSave(name, providerSettings) } if (signal.aborted) return id @@ -3096,6 +3083,33 @@ export class ClineProvider return id } + /** + * Refresh the buffered overlay of every live sibling pinned to a saved profile and rebuild + * any task that follows it. The handler rebuild is independent of the pin: a task restored + * from history can follow profile A while its view pins profile B. + */ + private async refreshSiblingsAfterProfileSave(name: string, providerSettings: ProviderSettings): Promise { + for (const instance of ClineProvider.getAllInstances()) { + if (instance === this || instance._disposed || instance.pinnedProfileName !== name) { + continue + } + // Direct private access: compile-time safe across sibling instances. + await instance._saveViewLocalStateFromMutation({ apiConfiguration: providerSettings }) + } + + const { + name: _recordName, + id: _recordId, + ...taskSettings + } = providerSettings as ProviderSettings & { name?: string; id?: string } + for (const instance of ClineProvider.getAllInstances()) { + if (instance._disposed || instance.getCurrentTask()?.taskApiConfigName !== name) { + continue + } + instance.updateTaskApiHandlerIfNeeded(taskSettings, { forceRebuild: true }) + } + } + async deleteProviderProfile(profileToDelete: ProviderSettingsEntry) { const globalSettings = this.contextProxy.getValues() let profileToActivate: string | undefined = globalSettings.currentApiConfigName diff --git a/src/core/webview/__tests__/ClineProvider.spec.ts b/src/core/webview/__tests__/ClineProvider.spec.ts index 7bb1909905..1593f9d32f 100644 --- a/src/core/webview/__tests__/ClineProvider.spec.ts +++ b/src/core/webview/__tests__/ClineProvider.spec.ts @@ -7610,7 +7610,7 @@ describe("ClineProvider", () => { await provider.dispose() }) - it("should refresh the buffered overlay of another view pinned to the saved profile", async () => { + it("should refresh the buffered overlay of another view pinned to the activated profile", async () => { const saver = new ClineProvider( mockContext, mockOutputChannel, @@ -7636,13 +7636,88 @@ describe("ClineProvider", () => { await saver.upsertProviderProfile("shared-profile", providerSettings, true) - // The pinned view buffered a copy of the profile's settings; a non-activating save must - // refresh it, or its getState() keeps serving the pre-save configuration. + // The pinned view buffered a copy of the profile's settings; activating the profile must + // refresh that copy, or its getState() keeps serving the pre-save configuration. expect(pinned["viewLocalState"].apiConfiguration).toEqual(providerSettings) await saver.dispose() await pinned.dispose() }) + it("should refresh the buffered overlay of another view pinned to the saved profile on a non-activating save", async () => { + const saver = new ClineProvider( + mockContext, + mockOutputChannel, + "sidebar", + new ContextProxy(mockContext), + new WebviewFocusTracker(), + ) + const pinned = new ClineProvider( + mockContext, + mockOutputChannel, + "editor", + new ContextProxy(mockContext), + new WebviewFocusTracker(), + ) + await pinned["saveViewState"]("currentApiConfigName", "shared-profile") + // @ts-ignore - The double only backs the profile-store calls of the save path. + saver.providerSettingsManager = { + saveConfig: vi.fn().mockResolvedValue("shared-id"), + listConfig: vi.fn().mockResolvedValue([{ name: "shared-profile", id: "shared-id" }]), + setModeConfig: vi.fn().mockResolvedValue(undefined), + } + const providerSettings = { apiProvider: providerIdentifiers.anthropic, apiKey: "fresh-key" } + + await saver.upsertProviderProfile("shared-profile", providerSettings, false) + + // A save that does not activate still rewrites the profile on disk. Every other live view + // pinned to that profile buffered a copy of its settings, so without a refresh this save + // leaves them serving the previous token under the same profile name. + expect(pinned["viewLocalState"].apiConfiguration).toEqual(providerSettings) + + await saver.dispose() + await pinned.dispose() + }) + + it("should rebuild a sibling task that follows the saved profile even when its view pins another", async () => { + const saver = new ClineProvider( + mockContext, + mockOutputChannel, + "sidebar", + new ContextProxy(mockContext), + new WebviewFocusTracker(), + ) + const sibling = new ClineProvider( + mockContext, + mockOutputChannel, + "editor", + new ContextProxy(mockContext), + new WebviewFocusTracker(), + ) + // A task restored from history can follow profile A while its view pins profile B: the pin + // must not be the condition for rebuilding that task's handler. + await sibling["saveViewState"]("currentApiConfigName", "another-profile") + // updateTaskApiHandlerIfNeeded is private to ClineProvider, so the double is bound through a + // structural view; the assertion goes through `never` rather than `any` (AGENTS.md). + const rebuildSpy = vi.fn() + ;(sibling as never as { updateTaskApiHandlerIfNeeded: typeof rebuildSpy }).updateTaskApiHandlerIfNeeded = + rebuildSpy + vi.spyOn(sibling, "getCurrentTask").mockReturnValue({ taskApiConfigName: "shared-profile" } as never) + // @ts-ignore - The double only backs the profile-store calls of the save path. + saver.providerSettingsManager = { + saveConfig: vi.fn().mockResolvedValue("shared-id"), + listConfig: vi.fn().mockResolvedValue([{ name: "shared-profile", id: "shared-id" }]), + setModeConfig: vi.fn().mockResolvedValue(undefined), + } + const providerSettings = { apiProvider: providerIdentifiers.anthropic, apiKey: "fresh-key" } + + await saver.upsertProviderProfile("shared-profile", providerSettings, false) + + expect(rebuildSpy).toHaveBeenCalledWith(providerSettings, { forceRebuild: true }) + + await saver.dispose() + await sibling.dispose() + }) + it("should roll back the shared writes when setValues per-view persistence fails", async () => { const provider = new ClineProvider( mockContext, From 44cf427a28200c279d0bf4ef5c92b35787f2ebe5 Mon Sep 17 00:00:00 2001 From: Eason Liang <136036952+easonLiangWorldedtech@users.noreply.github.com> Date: Thu, 5 Nov 2026 15:13:01 +0800 Subject: [PATCH 30/42] fix(webview): exempt keys ContextProxy does not count from the rollback generation guard _restoreSharedValuesAfterFailedViewWrite gates every key on the per-key write generation the setter captured. ContextProxy counts only cached global-state writes: secrets go through storeSecret and pass-through keys straight to the Memento, and neither advances the map, so those keys are captured with generation 1 and still read 0 afterwards. The guard is never satisfiable for them, which exempts exactly the keys whose value cannot be compared back (a secret is not in getValues, a pass-through key is not cached) from the rollback of their own failed attempt: after a failed per-view write the secret and the durable task history stay at the value the failed attempt wrote while every other key is restored. The filter now skips the generation clause for keys the repo's own predicates say ContextProxy does not count - isSecretStateKey from @roo-code/types and isPassThroughStateKey from ../config/ContextProxy - and keeps it everywhere else. ClineProvider.ts 6456 -> 6464 lines. Tests (three cases, all red before the change). - a secret key (nanoGptApiKey) written alongside a counted key with the per-view write failing: asserts the store moved to the new value and the cache is back to the old one; failed with expected 'new-secret' to be 'old-secret'. storeSecret is fire-and-forget, so the attempted value is asserted by presence, not order. - a pass-through key (taskHistory) in the same shape: asserts the Memento was written the new history and then the old one; received only the new write before the fix. The double delegates to the real store, because replacing it would also silence the read-back the guard compares. - the guard's own case: a concurrent provider re-writes the very value the attempt wrote, so only the generation distinguishes them; asserts the newer write stands. Without the generation clause it reads expected 'architect' to be 'code'. Controls (ClineProvider.ts snapshotted at 8a5977a75b, restored by content hash after each): drop the exemption (the previous guard) -> the secret and pass-through cases fail and the other three pass; delete the generation clause -> only the same-value case fails, so the guard is still load-bearing for counted keys; delete only the secret arm -> only the secret case fails; delete only the pass-through arm -> only the pass-through case fails. Gates: prettier --check clean; tsc --noEmit -p . clean; eslint --max-warnings=0 clean on both files with no suppression count changed; vitest core/webview + core/config 44 files / 1304 tests green (1301 before, +3 cases). Scope 815 -> 818 extension executable lines (types 8). --- src/core/webview/ClineProvider.ts | 12 +- .../webview/__tests__/ClineProvider.spec.ts | 146 ++++++++++++++++++ 2 files changed, 156 insertions(+), 2 deletions(-) diff --git a/src/core/webview/ClineProvider.ts b/src/core/webview/ClineProvider.ts index 1dde5a54a3..79bcb7e11d 100644 --- a/src/core/webview/ClineProvider.ts +++ b/src/core/webview/ClineProvider.ts @@ -76,6 +76,7 @@ import { modelIdKeys, providerIdentifiers, PROVIDER_SETTINGS_KEYS, + isSecretStateKey, } from "@roo-code/types" import { RateLimitClock, createRateLimitClock } from "../task/RateLimitClock" import { TaskRegistry } from "../task/TaskRegistry" @@ -132,7 +133,7 @@ import { t } from "../../i18n" import { buildApiHandler } from "../../api" import { forceFullModelDetailsLoad, hasLoadedFullDetails } from "../../api/providers/fetchers/lmstudio" -import { ContextProxy } from "../config/ContextProxy" +import { ContextProxy, isPassThroughStateKey } from "../config/ContextProxy" import { withoutInvalidDisplaySettings } from "../config/displaySettings" import { ProviderSettingsManager, ProviderSettingsNotFoundError } from "../config/ProviderSettingsManager" import { CustomModesManager } from "../config/CustomModesManager" @@ -6571,9 +6572,16 @@ export class ClineProvider for (const key of Object.keys(attempted) as (keyof RooCodeSettings)[]) { const generation = generations[key] + // ContextProxy does not count every key: secrets go through storeSecret and pass-through + // keys straight to the Memento, and neither advances the per-key write generation, so the + // expectation this setter recorded for them (generation 1 against a stored 0) can never + // match and would exempt those keys from the rollback of their own failed attempt. + const uncountedHere = isSecretStateKey(key) || isPassThroughStateKey(key) if ( this.contextProxy.getValue(key) === attempted[key] && - (generation === undefined || this.contextProxy.getStateWriteGeneration(key as never) === generation) + (generation === undefined || + uncountedHere || + this.contextProxy.getStateWriteGeneration(key as never) === generation) ) { ;(rollback as Record)[key] = previous[key] } diff --git a/src/core/webview/__tests__/ClineProvider.spec.ts b/src/core/webview/__tests__/ClineProvider.spec.ts index 1593f9d32f..6b03410818 100644 --- a/src/core/webview/__tests__/ClineProvider.spec.ts +++ b/src/core/webview/__tests__/ClineProvider.spec.ts @@ -7782,6 +7782,152 @@ describe("ClineProvider", () => { mockContext.globalState.update = originalUpdate await provider.dispose() }) + it("should roll back a secret key that ContextProxy does not track with a write generation", async () => { + const provider = new ClineProvider( + mockContext, + mockOutputChannel, + "sidebar", + new ContextProxy(mockContext), + new WebviewFocusTracker(), + ) + await provider.contextProxy.setValue("nanoGptApiKey", "old-secret") + await provider.contextProxy.setValue("mode", "architect") + const secretStore = vi.spyOn(mockContext.secrets, "store") + const originalUpdate = mockContext.globalState.update + mockContext.globalState.update = vi.fn().mockImplementation((key: string) => { + if (key === "viewStates") { + return Promise.reject(new Error("storage unavailable")) + } + return Promise.resolve() + }) + + await expect(provider.setValues({ nanoGptApiKey: "new-secret", mode: "code" })).rejects.toThrow( + "storage unavailable", + ) + + // ContextProxy routes secret keys through storeSecret, which never advances the per-key + // write generation the rollback guard compares against. A key it does not count is captured + // with generation 1 and still reads 0 afterwards, so the guard excludes it and the secret + // alone stays at the value the failed attempt wrote while every other key is restored. + // The attempt did move the secret: ContextProxy.storeSecret is fire-and-forget, so + // only the presence of the attempted value and the restored end state are deterministic. + expect(secretStore.mock.calls.map(([key, value]) => [key, value])).toContainEqual([ + "nanoGptApiKey", + "new-secret", + ]) + expect(provider.getValue("mode")).toBe("architect") + expect(provider.contextProxy.getSecret("nanoGptApiKey")).toBe("old-secret") + + mockContext.globalState.update = originalUpdate + await provider.dispose() + }) + + it("should keep the generation guard for a counted key whose concurrent write carried the same value", async () => { + const provider = new ClineProvider( + mockContext, + mockOutputChannel, + "sidebar", + new ContextProxy(mockContext), + new WebviewFocusTracker(), + ) + await provider.contextProxy.setValue("mode", "architect") + await provider.contextProxy.setValue("currentApiConfigName", "current-config") + const originalUpdate = mockContext.globalState.update + let rejectViews: (error: Error) => void = () => {} + let viewWrites = 0 + mockContext.globalState.update = vi.fn().mockImplementation((key: string) => { + if (key === "viewStates") { + // The attempt's own per-view write is parked below; the concurrent write's must land. + viewWrites++ + if (viewWrites === 1) { + return new Promise((_, reject) => (rejectViews = reject)) + } + return Promise.resolve() + } + return Promise.resolve() + }) + + const attempt = provider.setValues({ mode: "code", currentApiConfigName: "other-config" }) + await vi.waitFor(() => expect(provider.getValue("mode")).toBe("code")) + // A concurrent provider re-writes the very value this attempt wrote: the stored value + // cannot tell the two writes apart, only the per-key generation can. + await provider.contextProxy.setValue("mode", "code") + rejectViews(new Error("storage unavailable")) + await expect(attempt).rejects.toThrow("storage unavailable") + + // Restoring the captured "architect" here would undo a newer write that this rollback + // did not make, for every view that reads shared state. + expect(provider.getValue("mode")).toBe("code") + expect(provider.getValue("currentApiConfigName")).toBe("current-config") + + mockContext.globalState.update = originalUpdate + await provider.dispose() + }) + + it("should roll back a pass-through key that ContextProxy hands straight to the Memento", async () => { + const provider = new ClineProvider( + mockContext, + mockOutputChannel, + "sidebar", + new ContextProxy(mockContext), + new WebviewFocusTracker(), + ) + const firstHistory = [ + { + id: "task-1", + number: 1, + ts: 1700000000000, + task: "first", + tokensIn: 1, + tokensOut: 1, + totalCost: 0, + }, + ] + const secondHistory = [ + { + id: "task-2", + number: 2, + ts: 1700000000001, + task: "second", + tokensIn: 2, + tokensOut: 2, + totalCost: 0, + }, + ] + await provider.contextProxy.setValue("taskHistory", firstHistory as never) + await provider.contextProxy.setValue("mode", "architect") + const originalUpdate = mockContext.globalState.update + // The double must still move the Memento: a pass-through key is read back from there, + // so replacing the store outright would hide the very write under test. + const globalStore = vi.fn().mockImplementation((key: string, value: unknown) => { + if (key === "viewStates") { + return Promise.reject(new Error("storage unavailable")) + } + return originalUpdate(key, value as never) + }) + mockContext.globalState.update = globalStore + + await expect(provider.setValues({ taskHistory: secondHistory as never, mode: "code" })).rejects.toThrow( + "storage unavailable", + ) + + // taskHistory is a pass-through key: ContextProxy writes it straight to the Memento and + // never advances its write generation, so a guard that demands one leaves the durable + // history at the value the failed attempt wrote. + // taskHistory is a pass-through key: ContextProxy writes it straight to the Memento and + // never advances its write generation, so a guard that still demands one for it leaves + // the durable history at the value the failed attempt wrote while every other key is + // restored. The write sequence is the observable that separates a restored key from + // one the rollback never touched. + expect(globalStore.mock.calls.filter(([key]) => key === "taskHistory").map(([, value]) => value)).toEqual([ + secondHistory, + firstHistory, + ]) + expect(provider.getValue("mode")).toBe("architect") + + mockContext.globalState.update = originalUpdate + await provider.dispose() + }) it("should serve this view's restored mode through getState()", async () => { const provider = new ClineProvider( From ad1fd9be42d26604beba26386b07258d829eb19e Mon Sep 17 00:00:00 2001 From: Eason Liang <136036952+easonLiangWorldedtech@users.noreply.github.com> Date: Thu, 5 Nov 2026 15:17:23 +0800 Subject: [PATCH 31/42] test(webview): make the provider-filter assertion bite in both seeding rows CodeRabbit's point measured rather than argued. The two it.each rows share the store order ["Zoo Gateway", "Other", "Zoo Gateway 2"], so only one of them can ever fail expect(...).not.toContain("Other"): with the stale profile first the every-profile loop breaks before it reaches the non-gateway profile, so that row cannot observe the filter at all. Mutants run against 27a2836d1, production untouched (blob 8a5977a75b, restored by content hash after each): - drop the provider filter in ensureZooGatewayProfileSeeded: fixture as shipped -> 1 of the 2 rows fails (expected [ 'Zoo Gateway', 'Other', ...1 ] to not include 'Other'); with "Other" leading the store -> both rows fail. The assertion goes from one-row to two-row coverage. - check only the first gateway profile (the bug the comment describes): 1 row fails on the handleZooCodeCallback assertion, before and after the reorder, so the reorder does not weaken the detection this fixture pair exists for. - no mutant: 397 tests in the file pass. Test-only: the store order of the two rows moves and the comment records why "Other" leads. No assertion was added, weakened or deleted - nothing deleted here, duplicate or coverage - so the number a maintainer needs is 0 deleted-duplicate, 0 deleted-coverage, 1 assertion made load-bearing in a second row. Gates: prettier --check, tsc --noEmit -p . and eslint --max-warnings=0 clean; vitest core/webview + core.config suites 44 files / 1304 tests green. --- src/core/webview/__tests__/ClineProvider.spec.ts | 13 +++++++------ 1 file changed, 7 insertions(+), 6 deletions(-) diff --git a/src/core/webview/__tests__/ClineProvider.spec.ts b/src/core/webview/__tests__/ClineProvider.spec.ts index 6b03410818..3deb339fa1 100644 --- a/src/core/webview/__tests__/ClineProvider.spec.ts +++ b/src/core/webview/__tests__/ClineProvider.spec.ts @@ -10658,19 +10658,20 @@ describe("ClineProvider - Comprehensive Edit/Delete Edge Cases", () => { expect(handleSpy).toHaveBeenCalledWith("current-token") }) - // The up-to-date guard reads every zoo-gateway profile rather than one end of the list, and it - // skips profiles that belong to another provider. With a single profile in the store a - // first-only, a last-only and an every-profile check all behave the same, so the order of the - // two rows below is what pins the guard down. + // The up-to-date guard reads every zoo-gateway profile rather than one end of the list, and + // it skips profiles that belong to another provider. With a single profile in the store a + // first-only, a last-only and an every-profile check all behave the same, so the order of + // the two rows below is what pins the guard down. "Other" leads the store in both rows so + // that a guard which stopped filtering by provider is caught by either row, not by one. it.each([ { title: "re-seeds when a later zoo-gateway profile is stale and the first is current", - profiles: ["Zoo Gateway", "Other", "Zoo Gateway 2"], + profiles: ["Other", "Zoo Gateway", "Zoo Gateway 2"], staleProfile: "Zoo Gateway 2", }, { title: "re-seeds when the first zoo-gateway profile is stale and the last is current", - profiles: ["Zoo Gateway", "Other", "Zoo Gateway 2"], + profiles: ["Other", "Zoo Gateway", "Zoo Gateway 2"], staleProfile: "Zoo Gateway", }, ])("$title", async ({ profiles, staleProfile }) => { From 35215af38b4ad4a8fbcd11d17af1c28e381ac5d4 Mon Sep 17 00:00:00 2001 From: Eason Liang <136036952+easonLiangWorldedtech@users.noreply.github.com> Date: Thu, 5 Nov 2026 19:30:54 +0800 Subject: [PATCH 32/42] fix(config): refuse secret writes during a reset and clear the guard when it fails This branch had no write guard at all. There was no reset flag, storeSecret() had nothing telling it a reset was in progress, and resetAllState() cleared the two caches, deleted every global-state and secret key in a single Promise.all and reinitialized - the success path being the only path. A save issued while a reset was still inside its deletes could therefore land after the deletes and put back a value the user had just erased. This commit introduces the guard, so on this branch the refusal is new behaviour rather than a repair of an existing one, and it should be read as scope rather than as a bug fix to code that already refused writes. What lands: a resetting field, a rejection at the top of storeSecret() carrying the key in failed so a caller can tell a refused save from a committed one, resetting raised as the first statement of resetAllState() and lowered in a finally wrapping the whole body. The body itself is untouched: this lineage has neither a pending-write barrier nor write-owner clears, and importing them from #2235 would have imported a different unit's design instead of answering this unit's defect. initialize() performs no writes, so the refusal cannot make a reset wait on itself. Two cases, because the guard has two halves and the refusal is the new observable here, so it is tested on its own rather than as a phase of the leak case: - refuses a secret write issued while a reset is still inside its delete pass - accepts a secret write again after a reset whose delete pass rejected Assertions read captured call arguments (mockSecrets.store.mock.calls filtered on the key) and the cache and storage read-backs, not toHaveBeenCalledWith: that matcher compares the way toEqual does and drops undefined-valued keys, so a loose matcher would pass on a tree where nothing is refused at all. Controls, measured in five steps rather than described. Baseline at e398b6737d: Test Files 10 passed (10), Tests 314 passed (314). Refusal case alone with production untouched: 1 failed | 314 passed (315), AssertionError: expected undefined to be an instance of SettingsWriteError - with no refusal the mid-reset save simply succeeds. Guard and refusal with the flag lowered only on the success path: 10 passed (10), 315 passed (315). Leak case added against exactly that shape, which is the negative control for the finally: 1 failed of 316 with the production consequence in the message - promise rejected "SettingsWriteError: Could not store apiKey: secret writes are refused while state is being reset" instead of resolving. With the try/finally: Test Files 10 passed (10), Tests 316 passed (316), identical before and after prettier. gates: tsc -p . --noEmit exit 0, eslint --max-warnings=0 --no-warn-ignored on both files exit 0, and the recorded suppression counts for the two touched files stand at 1 and 5 across a --prune-suppressions run; prettier --check exits 0 on the working copies and 0 on the HEAD copies fed through the same invocation, so a format failure here would be this commit's. src/eslint-suppressions.json untouched. Size posture, with the pair printed: scripts/stryker-diff.mjs ci --base e943530c848624bd3054c960be1e4fb0b658509a (main's tip, this PR's recorded base) --head e398b6737ddb52513dfe986eb59fdc321537d324 (this commit's parent) exits 1 and puts the extension bucket at 566 changed executable lines against MAX_CHANGED_LINES 500. This commit adds 29 added / 14 deleted in src/core/config/ContextProxy.ts plus 69 lines in its spec, and the spec half is excluded from the bucket by the /__tests__/ segment at scripts/stryker-diff.mjs:85. Stryker itself could not start locally for either package (spawnSync node_modules\.bin\stryker ENOENT), so no mutants were scored here and only the size line is a real measurement; it belongs in the PR body or the maintainers' queue rather than being argued in a commit on a branch declared final. This ports the answer measured on vps2/n2-viewstates-durability and vps2/n4-values-reset so the three sibling units do not ship three different answers to one defect. It closes no review row on this PR of itself. --- src/core/config/ContextProxy.ts | 43 ++++++++---- .../config/__tests__/ContextProxy.spec.ts | 69 +++++++++++++++++++ 2 files changed, 98 insertions(+), 14 deletions(-) diff --git a/src/core/config/ContextProxy.ts b/src/core/config/ContextProxy.ts index ad3b1fb3da..1ea3de7d58 100644 --- a/src/core/config/ContextProxy.ts +++ b/src/core/config/ContextProxy.ts @@ -79,6 +79,9 @@ export class ContextProxy { private secretCache: SecretState private _isInitialized = false + // Raised for the whole duration of a reset and cleared in a finally, so a reset that fails + // mid-way cannot leave the store refusing every later secret write; see resetAllState. + private resetting = false constructor(context: vscode.ExtensionContext) { this.originalContext = context @@ -452,6 +455,13 @@ export class ContextProxy { } storeSecret(key: SecretStateKey, value?: string) { + // Refused rather than deferred: a deferred secret write would re-store exactly the value the + // user asked to erase, and a silently dropped one would lose the save. + if (this.resetting) { + return Promise.reject( + new SettingsWriteError([], [key], new Error("secret writes are refused while state is being reset")), + ) + } // Update cache. const owner = {} this.secretWriteOwner.set(key, owner) @@ -725,22 +735,27 @@ export class ContextProxy { * @returns A promise that resolves when all reset operations are complete */ public async resetAllState() { - // Clear in-memory caches - this.stateCache = {} - this.secretCache = {} - // A write that started before this reset must not restore its pre-reset value when it - // rejects afterwards, so advance every generation the pending writes still hold. - for (const key of this.stateWriteGenerations.keys()) { - this.stateWriteGenerations.set(key, (this.stateWriteGenerations.get(key) ?? 0) + 1) - } + this.resetting = true + try { + // Clear in-memory caches + this.stateCache = {} + this.secretCache = {} + // A write that started before this reset must not restore its pre-reset value when it + // rejects afterwards, so advance every generation the pending writes still hold. + for (const key of this.stateWriteGenerations.keys()) { + this.stateWriteGenerations.set(key, (this.stateWriteGenerations.get(key) ?? 0) + 1) + } - await Promise.all([ - ...GLOBAL_STATE_KEYS.map((key) => this.originalContext.globalState.update(key, undefined)), - ...SECRET_STATE_KEYS.map((key) => this.originalContext.secrets.delete(key)), - ...GLOBAL_SECRET_KEYS.map((key) => this.originalContext.secrets.delete(key)), - ]) + await Promise.all([ + ...GLOBAL_STATE_KEYS.map((key) => this.originalContext.globalState.update(key, undefined)), + ...SECRET_STATE_KEYS.map((key) => this.originalContext.secrets.delete(key)), + ...GLOBAL_SECRET_KEYS.map((key) => this.originalContext.secrets.delete(key)), + ]) - await this.initialize() + await this.initialize() + } finally { + this.resetting = false + } } private static _instance: ContextProxy | null = null diff --git a/src/core/config/__tests__/ContextProxy.spec.ts b/src/core/config/__tests__/ContextProxy.spec.ts index fdd497bc79..e86c5fb2c5 100644 --- a/src/core/config/__tests__/ContextProxy.spec.ts +++ b/src/core/config/__tests__/ContextProxy.spec.ts @@ -160,6 +160,75 @@ describe("ContextProxy", () => { // that storage no longer holds. expect(proxy.getGlobalState("apiProvider")).toBeUndefined() }) + // This branch carried no write guard at all before these two cases: resetAllState cleared the + // caches and deleted storage with nothing telling storeSecret that a reset was running, so a + // save issued mid-reset could land after the deletes and resurrect a value the user had just + // erased. The refusal is the new observable here rather than an existing one, so it gets its + // own case instead of being a phase of the leak case. + it("refuses a secret write issued while a reset is still inside its delete pass", async () => { + const erases: { reject: (error: Error) => void }[] = [] + mockSecrets.delete.mockImplementation((key: string) => { + if (key === "apiKey") { + return new Promise((_, reject) => { + erases.push({ reject }) + }) + } + return Promise.resolve() + }) + + const resetting = proxy.resetAllState() + // The reset yields before it reaches its delete pass, so let it get there before asking the + // store to write. + await new Promise((resolve) => { + setTimeout(resolve, 10) + }) + expect(erases.length).toBe(1) + + const refused = await proxy.storeSecret("apiKey", "saved-mid-reset").then( + () => undefined, + (error: unknown) => error, + ) + expect(refused).toBeInstanceOf(SettingsWriteError) + expect(String((refused as Error).message)).toContain("secret writes are refused while state is being reset") + // Refused rather than deferred: a deferred write would re-store the value this reset is + // in the middle of erasing. + // Refused rather than deferred, and not silently written either: the cache the reset already + // cleared stays empty and no store call was made for the key. + expect(proxy.getSecret("apiKey")).toBeUndefined() + expect(mockSecrets.store.mock.calls.filter((call: readonly unknown[]) => call[0] === "apiKey").length).toBe( + 0, + ) + + erases.forEach((erase) => { + erase.reject(new Error("keychain locked")) + }) + await expect(resetting).rejects.toThrow("keychain locked") + }) + it("accepts a secret write again after a reset whose delete pass rejected", async () => { + const durable = new Map() + mockSecrets.get.mockImplementation(async (key: string) => durable.get(key)) + mockSecrets.store.mockImplementation(async (key: string, value: string) => { + durable.set(key, value) + }) + mockSecrets.delete.mockImplementation(async (key: string) => { + if (key === "apiKey") { + throw new Error("keychain locked") + } + durable.delete(key) + }) + + await expect(proxy.resetAllState()).rejects.toThrow("keychain locked") + + // The half that bites: the delete pass is a single Promise.all, so one keychain rejection + // rejects resetAllState itself. Unless the guard is lowered on that path too, every later + // save is refused for the life of the instance while resetState() has already aborted on the + // same error, so the user cannot get a key back without restarting the extension host. + // Measured as a save that resolves and reads back through storage and cache, not as an + // absence of errors. + await expect(proxy.storeSecret("apiKey", "written-after-failed-reset")).resolves.toBeUndefined() + expect(await mockSecrets.get("apiKey")).toBe("written-after-failed-reset") + expect(proxy.getSecret("apiKey")).toBe("written-after-failed-reset") + }) it("should restore the last persisted value when two overlapping writes both reject", async () => { await proxy.updateGlobalState("apiProvider", "anthropic") From ad8b26c97920a0df35454322d8d6d7e47257d175 Mon Sep 17 00:00:00 2001 From: Eason Liang <136036952+easonLiangWorldedtech@users.noreply.github.com> Date: Fri, 6 Nov 2026 00:00:01 +0800 Subject: [PATCH 33/42] fix(webview): clear every live view's buffer on reset resetState cleared only this view's view-local buffer, but the shared store it just cleared is what every view reads from - and getState() reads the view-local buffer first. A sibling view therefore kept serving its pre-reset mode (and its stale settings) after the reset. Every live instance is cleared now. ClineProvider.spec 364 passed, tsc --noEmit 0 errors, eslint --max-warnings=0 exit 0. --- src/core/webview/ClineProvider.ts | 7 ++++++- 1 file changed, 6 insertions(+), 1 deletion(-) diff --git a/src/core/webview/ClineProvider.ts b/src/core/webview/ClineProvider.ts index 79bcb7e11d..5b2d450c73 100644 --- a/src/core/webview/ClineProvider.ts +++ b/src/core/webview/ClineProvider.ts @@ -4758,7 +4758,12 @@ export class ClineProvider await this.contextProxy.resetAllState() - // Clear view-local state cache so getState() falls back to ContextProxy defaults. + // Clear the view-local buffer of EVERY live view, not only this one. getState() reads the + // view-local buffer before the shared store, so a sibling view would otherwise keep serving + // its pre-reset mode while the shared state says the reset happened. + for (const instance of ClineProvider.getAllInstances()) { + instance._clearViewLocalState() + } this._clearViewLocalState() // Clear this view's persisted entry too, so the reset selections are not From 3cc8bbb62334b16faa05a2e5bebd74892fd51cf3 Mon Sep 17 00:00:00 2001 From: Eason Liang <136036952+easonLiangWorldedtech@users.noreply.github.com> Date: Fri, 6 Nov 2026 00:04:42 +0800 Subject: [PATCH 34/42] test(webview): swap the manager through MemberSwapTarget and stop disposing in the mock Two test-quality findings from review: the new provider-settings doubles used `(provider as any)` plus `as any`, when the file already has a named view for that (MemberSwapTarget), and the sticky-mode view mock fired onDidDispose's callback during registration, so the view was disposed before resolveWebviewView finished and the stale check took the sidebar branch. The mock now only returns a disposable; tests that need a disposal fire it themselves. ClineProvider.spec 397 + sticky-mode 27 passed, tsc --noEmit 0 errors, eslint --max-warnings=0 exit 0 (suppressions pruned, total down, never up). --- .../webview/__tests__/ClineProvider.spec.ts | 64 +++++++++---------- .../ClineProvider.sticky-mode.spec.ts | 7 +- 2 files changed, 35 insertions(+), 36 deletions(-) diff --git a/src/core/webview/__tests__/ClineProvider.spec.ts b/src/core/webview/__tests__/ClineProvider.spec.ts index 3deb339fa1..2e1c61f4c6 100644 --- a/src/core/webview/__tests__/ClineProvider.spec.ts +++ b/src/core/webview/__tests__/ClineProvider.spec.ts @@ -4677,13 +4677,13 @@ describe("ClineProvider", () => { } provider["initialModeConfigIds"] = Promise.resolve({ architect: "test-id" }) - ;(provider as any).providerSettingsManager = { + ;(provider as MemberSwapTarget).providerSettingsManager = { getModeConfigId: vi.fn().mockResolvedValue("test-id"), listConfig: vi.fn().mockResolvedValue([profile]), activateProfile: vi.fn().mockResolvedValue(profile), setModeConfig: vi.fn(), getProfile: vi.fn().mockResolvedValue(profile), - } as any + } // Switch to architect mode await messageHandler({ type: "mode", text: "architect" }) @@ -4929,7 +4929,7 @@ describe("ClineProvider", () => { await provider.resolveWebviewView(mockWebviewView) const messageHandler = (mockWebviewView.webview.onDidReceiveMessage as any).mock.calls[0][0] - ;(provider as any).providerSettingsManager = { + ;(provider as MemberSwapTarget).providerSettingsManager = { getModeConfigId: vi.fn().mockResolvedValue(undefined), listConfig: vi .fn() @@ -4937,7 +4937,7 @@ describe("ClineProvider", () => { { name: "current-config", id: "current-id", apiProvider: providerIdentifiers.anthropic }, ]), setModeConfig: vi.fn(), - } as any + } await provider.setValue("currentApiConfigName", "current-config") @@ -4958,12 +4958,12 @@ describe("ClineProvider", () => { name: "new-config", } - ;(provider as any).providerSettingsManager = { + ;(provider as MemberSwapTarget).providerSettingsManager = { activateProfile: vi.fn().mockResolvedValue(profile), listConfig: vi.fn().mockResolvedValue([profile]), setModeConfig: vi.fn(), getModeConfigId: vi.fn().mockResolvedValue(undefined), - } as any + } // First set the mode await messageHandler({ type: "mode", text: "architect" }) @@ -4985,12 +4985,12 @@ describe("ClineProvider", () => { apiProvider: providerIdentifiers.anthropic, } - ;(provider as any).providerSettingsManager = { + ;(provider as MemberSwapTarget).providerSettingsManager = { activateProfile: vi.fn().mockResolvedValue(profile), listConfig: vi.fn().mockResolvedValue([profile]), setModeConfig: vi.fn(), getModeConfigId: vi.fn().mockResolvedValue(undefined), - } as any + } // First set the mode await messageHandler({ type: "mode", text: "architect" }) @@ -5161,7 +5161,7 @@ describe("ClineProvider", () => { await provider.resolveWebviewView(mockWebviewView) const messageHandler = (mockWebviewView.webview.onDidReceiveMessage as any).mock.calls[0][0] - ;(provider as any).providerSettingsManager = { + ;(provider as MemberSwapTarget).providerSettingsManager = { listConfig: vi .fn() .mockResolvedValue([ @@ -5169,7 +5169,7 @@ describe("ClineProvider", () => { ]), saveConfig: vi.fn().mockResolvedValue("test-id"), setModeConfig: vi.fn(), - } as any + } // Update API configuration await messageHandler({ @@ -5512,13 +5512,13 @@ describe("ClineProvider", () => { } provider["initialModeConfigIds"] = Promise.resolve({ architect: "saved-config-id" }) - ;(provider as any).providerSettingsManager = { + ;(provider as MemberSwapTarget).providerSettingsManager = { getModeConfigId: vi.fn().mockResolvedValue("saved-config-id"), listConfig: vi.fn().mockResolvedValue([profile]), activateProfile: vi.fn().mockResolvedValue(profile), setModeConfig: vi.fn(), getProfile: vi.fn().mockResolvedValue(profile), - } as any + } // Switch to architect mode await provider.handleModeSwitch("architect") @@ -5535,8 +5535,8 @@ describe("ClineProvider", () => { expect(mockPostMessage).toHaveBeenCalledWith(expect.objectContaining({ type: "state" })) }) - test("keeps the current config locally when switching to a mode without a config", async () => { - ;(provider as any).providerSettingsManager = { + test("saves current config when switching to mode without config", async () => { + ;(provider as MemberSwapTarget).providerSettingsManager = { getModeConfigId: vi.fn().mockResolvedValue(undefined), listConfig: vi .fn() @@ -5544,7 +5544,7 @@ describe("ClineProvider", () => { { name: "current-config", id: "current-id", apiProvider: providerIdentifiers.anthropic }, ]), setModeConfig: vi.fn(), - } as any + } // Mock the ContextProxy's getValue method to return the current config name const contextProxy = (provider as any).contextProxy @@ -5572,13 +5572,13 @@ describe("ClineProvider", () => { const listConfig = vi.fn().mockResolvedValue([]) const activateProfile = vi.fn().mockResolvedValue({}) - ;(provider as any).providerSettingsManager = { + ;(provider as MemberSwapTarget).providerSettingsManager = { getModeConfigId, listConfig, activateProfile, setModeConfig: vi.fn(), getProfile: vi.fn(), - } as any + } const controller = new AbortController() controller.abort() @@ -5603,13 +5603,13 @@ describe("ClineProvider", () => { }) const activateProfile = vi.fn().mockResolvedValue(profile) - ;(provider as any).providerSettingsManager = { + ;(provider as MemberSwapTarget).providerSettingsManager = { getModeConfigId, listConfig, activateProfile, setModeConfig: vi.fn(), getProfile: vi.fn().mockResolvedValue(profile), - } as any + } await provider["handleModeSwitchUnlocked"]("architect", undefined, controller.signal) @@ -5920,14 +5920,14 @@ describe("ClineProvider", () => { const activateProfile = vi.fn().mockResolvedValue({ name: "survivor" }) - ;(provider as any).providerSettingsManager = { + ;(provider as MemberSwapTarget).providerSettingsManager = { deleteConfig: vi.fn().mockResolvedValue(undefined), activateProfile, getProfile: vi.fn().mockResolvedValue({ name: "survivor", apiProvider: providerIdentifiers.anthropic, }), - } as any + } await provider.deleteProviderProfile(profileToDelete) @@ -6405,14 +6405,14 @@ describe("ClineProvider", () => { await provider.resolveWebviewView(mockWebviewView) const messageHandler = (mockWebviewView.webview.onDidReceiveMessage as any).mock.calls[0][0] - ;(provider as any).providerSettingsManager = { + ;(provider as MemberSwapTarget).providerSettingsManager = { setModeConfig: vi.fn().mockRejectedValue(new Error("Failed to update mode config")), listConfig: vi .fn() .mockResolvedValue([ { name: "test-config", id: "test-id", apiProvider: providerIdentifiers.anthropic }, ]), - } as any + } // Mock getState to provide necessary data vi.spyOn(provider, "getState").mockResolvedValue({ @@ -6438,7 +6438,7 @@ describe("ClineProvider", () => { await provider.resolveWebviewView(mockWebviewView) const messageHandler = (mockWebviewView.webview.onDidReceiveMessage as any).mock.calls[0][0] - ;(provider as any).providerSettingsManager = { + ;(provider as MemberSwapTarget).providerSettingsManager = { setModeConfig: vi.fn(), saveConfig: vi.fn().mockResolvedValue(undefined), listConfig: vi @@ -6446,7 +6446,7 @@ describe("ClineProvider", () => { .mockResolvedValue([ { name: "test-config", id: "test-id", apiProvider: providerIdentifiers.anthropic }, ]), - } as any + } const testApiConfig = { apiProvider: providerIdentifiers.anthropic, @@ -6483,7 +6483,7 @@ describe("ClineProvider", () => { ;(buildApiHandler as any).mockImplementationOnce(() => { throw new Error("API handler error") }) - ;(provider as any).providerSettingsManager = { + ;(provider as MemberSwapTarget).providerSettingsManager = { setModeConfig: vi.fn(), saveConfig: vi.fn().mockResolvedValue(undefined), listConfig: vi @@ -6491,7 +6491,7 @@ describe("ClineProvider", () => { .mockResolvedValue([ { name: "test-config", id: "test-id", apiProvider: providerIdentifiers.anthropic }, ]), - } as any + } // Setup Task instance with auto-mock from the top of the file const mockCline = new Task(defaultTaskOptions) // Create a new mocked instance @@ -6526,7 +6526,7 @@ describe("ClineProvider", () => { await provider.resolveWebviewView(mockWebviewView) const messageHandler = (mockWebviewView.webview.onDidReceiveMessage as any).mock.calls[0][0] - ;(provider as any).providerSettingsManager = { + ;(provider as MemberSwapTarget).providerSettingsManager = { setModeConfig: vi.fn(), saveConfig: vi.fn().mockResolvedValue(undefined), listConfig: vi @@ -6534,7 +6534,7 @@ describe("ClineProvider", () => { .mockResolvedValue([ { name: "test-config", id: "test-id", apiProvider: providerIdentifiers.anthropic }, ]), - } as any + } const testApiConfig = { apiProvider: providerIdentifiers.anthropic, @@ -10492,7 +10492,7 @@ describe("ClineProvider - Comprehensive Edit/Delete Edge Cases", () => { const upsertSpy = vi.spyOn(provider, "upsertProviderProfile").mockResolvedValue("profile-id") vi.spyOn(provider, "postStateToWebview").mockResolvedValue(undefined) const postMessageSpy = vi.spyOn(provider, "postMessageToWebview").mockResolvedValue(undefined) - ;(provider as any).providerSettingsManager = { + ;(provider as MemberSwapTarget).providerSettingsManager = { listConfig: vi.fn().mockResolvedValue([]), } @@ -10513,7 +10513,7 @@ describe("ClineProvider - Comprehensive Edit/Delete Edge Cases", () => { it("logs and posts state when profile persistence fails", async () => { vi.spyOn(provider, "getState").mockRejectedValue(new Error("state unavailable")) vi.spyOn(provider, "postStateToWebview").mockResolvedValue(undefined) - ;(provider as any).providerSettingsManager = { + ;(provider as MemberSwapTarget).providerSettingsManager = { listConfig: vi.fn().mockResolvedValue([]), } @@ -10589,7 +10589,7 @@ describe("ClineProvider - Comprehensive Edit/Delete Edge Cases", () => { it("does nothing when no cached auth token exists", async () => { const handleSpy = vi.spyOn(provider, "handleZooCodeCallback").mockResolvedValue(undefined) - ;(provider as any).providerSettingsManager = { + ;(provider as MemberSwapTarget).providerSettingsManager = { listConfig: vi.fn(), } diff --git a/src/core/webview/__tests__/ClineProvider.sticky-mode.spec.ts b/src/core/webview/__tests__/ClineProvider.sticky-mode.spec.ts index 170999cbef..8d43ba8e5a 100644 --- a/src/core/webview/__tests__/ClineProvider.sticky-mode.spec.ts +++ b/src/core/webview/__tests__/ClineProvider.sticky-mode.spec.ts @@ -297,10 +297,9 @@ describe("ClineProvider - Sticky Mode", () => { cspSource: "vscode-webview://test-csp-source", }, visible: true, - onDidDispose: vi.fn().mockImplementation((callback) => { - callback() - return { dispose: vi.fn() } - }), + // Register only: firing the callback here disposes the view before resolveWebviewView finishes, + // which sends the later stale-check down the sidebar branch. Tests that need a disposal fire it. + onDidDispose: vi.fn().mockImplementation(() => ({ dispose: vi.fn() })), onDidChangeVisibility: vi.fn().mockImplementation(() => { return { dispose: vi.fn() } }), From 719f0d48b7d33a6c86a555ae2a53232322ad9c98 Mon Sep 17 00:00:00 2001 From: Eason Liang <136036952+easonLiangWorldedtech@users.noreply.github.com> Date: Wed, 11 Nov 2026 17:45:04 +0800 Subject: [PATCH 35/42] test(webview): pin profile split, same-call custom mode and failed write Pins three behaviours the CodeRabbit review asked about, all of them test-only. - getValues() exposes the restored profile name and the configuration it resolved to, while getState() and the state posted to the webview still resolve the shared profile. That split is what the review asks to close; both sides are pinned here so the eventual fix flips a visible assertion instead of passing unnoticed. - createTask registers the custom modes of a configuration before it calls setValues(), so a slug passed in the same call survives validation. The resolver fixture now answers from the custom-mode list the provider just read instead of accepting every slug, which is what pins the ordering. - handleZooCodeCallback: the existing case rejects the state read and never reaches the write, so its title now says so, and a second case drives saveConfig rejecting inside persistProviderProfile, which upsertProviderProfile swallows, logs and reports to the user while the state is still posted. --- .../webview/__tests__/ClineProvider.spec.ts | 158 +++++++++++++++++- 1 file changed, 157 insertions(+), 1 deletion(-) diff --git a/src/core/webview/__tests__/ClineProvider.spec.ts b/src/core/webview/__tests__/ClineProvider.spec.ts index 2e1c61f4c6..d37632dea7 100644 --- a/src/core/webview/__tests__/ClineProvider.spec.ts +++ b/src/core/webview/__tests__/ClineProvider.spec.ts @@ -17,6 +17,7 @@ import { type ExtensionMessage, type ExtensionState, type RooCodeSettings, + type ModeConfig, type WebviewMessage, ORGANIZATION_ALLOW_ALL, DEFAULT_CHECKPOINT_TIMEOUT_SECONDS, @@ -4113,6 +4114,62 @@ describe("ClineProvider", () => { expect(setValues).toHaveBeenCalledWith({ mode: "code" }) }) + + it("initializes a new task with a custom mode passed beside its own slug", async () => { + // Row 4509495977: createTask registers the custom modes of a configuration before it + // calls setValues(), and setValues() only keeps a mode the custom-mode store can already + // resolve. The double below makes a slug resolvable exactly once registration has stored + // it, so moving the registration after setValues() drops the mode here. + const slug = "release-reviewer" + const registered = new Map() + const updateCustomMode = vi.fn().mockImplementation(async (modeSlug: string, mode: ModeConfig) => { + registered.set(modeSlug, mode) + }) + ;(provider as MemberSwapTarget).customModesManager = { + updateCustomMode, + getCustomModes: vi.fn().mockImplementation(async () => [...registered.values()]), + } + const setValues = vi.spyOn(provider.contextProxy, "setValues").mockResolvedValue(undefined) + vi.spyOn(provider, "log").mockImplementation(() => {}) + + const { getModeBySlug, modes } = await import("../../../shared/modes") + const resolver = vi.mocked(getModeBySlug) + // The harness default answers every slug with the code mode (mock factory above). This test + // mirrors the real resolver instead: a slug is a mode only while the custom-mode list the + // provider just read holds it. The finally block re-applies the factory's answer so later + // tests are unaffected by this override. + const harnessDefaultMode: ModeConfig = { + slug: "code", + name: "Code Mode", + roleDefinition: "You are a code assistant", + groups: ["read", "edit"], + } + resolver.mockImplementation( + (modeSlug: string, customModes?: ModeConfig[]) => + customModes?.find((mode) => mode.slug === modeSlug) ?? modes.find((mode) => mode.slug === modeSlug), + ) + + try { + const mode: ModeConfig = { + slug, + name: "Release reviewer", + roleDefinition: "You review releases before they ship", + groups: ["read"], + } + + await provider + .createTask("hello", undefined, undefined, {}, hand({ customModes: [mode], mode: slug })) + .catch(() => undefined) // what happens after the configuration is written is not under test + + expect(updateCustomMode).toHaveBeenCalledWith(slug, mode) + expect(updateCustomMode.mock.invocationCallOrder[0]).toBeLessThan(setValues.mock.invocationCallOrder[0]) + // The mode the new task initializes with is the one getState() now reports. + expect((await provider.getState()).mode).toBe(slug) + } finally { + resolver.mockReset() + resolver.mockReturnValue(harnessDefaultMode) + } + }) }) test.each([ @@ -7419,6 +7476,69 @@ describe("ClineProvider", () => { await provider.dispose() }) + it("keeps the restored profile visible to public readers when the shared store names another profile", async () => { + const writer = new ClineProvider( + mockContext, + mockOutputChannel, + "sidebar", + new ContextProxy(mockContext), + new WebviewFocusTracker(), + ) + await writer["setViewStateId"]("shared-view") + await writer.saveViewState("mode", "architect") + await writer.saveViewState("currentApiConfigName", "my-profile") + + const provider = new ClineProvider( + mockContext, + mockOutputChannel, + "editor", + new ContextProxy(mockContext), + new WebviewFocusTracker(), + ) + const getProfile = vi.fn().mockResolvedValue({ + name: "my-profile", + apiProvider: providerIdentifiers.openrouter, + openRouterModelId: "model-x", + }) + ;(provider as MemberSwapTarget).providerSettingsManager = { getProfile } + // The writer has to release the id before this view adopts the entry it persisted. + await writer.dispose() + + // Another view activated a different profile in the shared store in the meantime, so the + // shared pair and the pair this view restores disagree on purpose. + await provider.contextProxy.setValue("currentApiConfigName", "shared-profile") + await provider.contextProxy.setProviderSettings({ apiProvider: providerIdentifiers.anthropic }) + await provider.contextProxy.setValue( + "viewStates", + mockContext.globalState.get("viewStates"), + ) + await provider["setViewStateId"]("shared-view", persistedViewStateClaim(mockContext, "shared-view")) + + expect(getProfile).toHaveBeenCalledWith({ name: "my-profile" }) + expect(provider["viewLocalState"]).toEqual({ + mode: "architect", + currentApiConfigName: "my-profile", + apiConfiguration: { apiProvider: providerIdentifiers.openrouter, openRouterModelId: "model-x" }, + }) + // Public reader 1: getValues() merges this view's buffer, so the restored name and the + // configuration it resolved to are visible outside the instance that loaded them. + expect(provider.getValues().currentApiConfigName).toBe("my-profile") + expect(provider.getValues().apiConfiguration).toEqual({ + apiProvider: providerIdentifiers.openrouter, + openRouterModelId: "model-x", + }) + // Public reader 2: getState() and the state posted to the webview still resolve the + // shared profile, while the mode they report is already the view-local one. That split is + // what row 4509495951 asks to close; pinning both sides here makes the fix flip a visible + // assertion instead of passing unnoticed. + const state = await provider.getState() + expect(state.currentApiConfigName).toBe("shared-profile") + expect(state.apiConfiguration).toMatchObject({ apiProvider: providerIdentifiers.anthropic }) + expect(state.mode).toBe("architect") + expect((await provider.getStateToPostToWebview()).currentApiConfigName).toBe("shared-profile") + await provider.dispose() + }) + it("should apply setValue mutations to global state and keep or clear the right buffer fields", async () => { const provider = new ClineProvider( mockContext, @@ -10510,7 +10630,7 @@ describe("ClineProvider - Comprehensive Edit/Delete Edge Cases", () => { ) }) - it("logs and posts state when profile persistence fails", async () => { + it("logs and posts state when the state read fails before the profile write", async () => { vi.spyOn(provider, "getState").mockRejectedValue(new Error("state unavailable")) vi.spyOn(provider, "postStateToWebview").mockResolvedValue(undefined) ;(provider as MemberSwapTarget).providerSettingsManager = { @@ -10525,6 +10645,42 @@ describe("ClineProvider - Comprehensive Edit/Delete Edge Cases", () => { // State must still be refreshed even when profile persistence fails. expect(provider.postStateToWebview).toHaveBeenCalled() }) + + it("reports the failed profile write and still posts state", async () => { + // Row 4509500273: the case above rejects getState(), so it never reaches the write. Here + // the read succeeds and saveConfig rejects inside persistProviderProfile, which + // upsertProviderProfile swallows, logs, and reports to the user. + vi.spyOn(provider, "getState").mockResolvedValue({ + apiConfiguration: { zooGatewayModelId: "anthropic/claude-sonnet-4" }, + } as never) + vi.spyOn(provider.contextProxy, "getProviderSettings").mockReturnValue({ + apiProvider: providerIdentifiers.anthropic, + } as never) + vi.spyOn(provider.contextProxy, "getValues").mockReturnValue({ + currentApiConfigName: "Anthropic", + } as never) + const postStateToWebview = vi.spyOn(provider, "postStateToWebview").mockResolvedValue(undefined) + const saveConfig = vi.fn().mockRejectedValue(new Error("saveConfig rejected")) + ;(provider as MemberSwapTarget).providerSettingsManager = { + listConfig: vi.fn().mockResolvedValue([]), + saveConfig, + } + + await provider.handleZooCodeCallback("zoo_ext_token") + + expect(saveConfig).toHaveBeenCalledWith( + "Zoo Gateway", + expect.objectContaining({ + apiProvider: providerIdentifiers.zooGateway, + zooSessionToken: "zoo_ext_token", + }), + ) + expect(mockOutputChannel.appendLine).toHaveBeenCalledWith( + expect.stringContaining("Error create new api configuration"), + ) + expect(vscode.window.showErrorMessage).toHaveBeenCalledWith("errors.create_api_config") + expect(postStateToWebview).toHaveBeenCalled() + }) it("updates every zoo-gateway profile and activates only the active one", async () => { vi.spyOn(provider, "getState").mockResolvedValue({ apiConfiguration: { zooGatewayModelId: "anthropic/claude-sonnet-4" }, From 4bfdc51518faf3c904741769861f64e2f5977de9 Mon Sep 17 00:00:00 2001 From: Eason Liang <136036952+easonLiangWorldedtech@users.noreply.github.com> Date: Wed, 11 Nov 2026 19:32:53 +0800 Subject: [PATCH 36/42] fix(api,webview): strip nested profile secrets at the API boundary, and hand readers the profile this view pinned getConfiguration() filtered only the top level of the object it hands out. The secret storage keys are keys of ProviderSettings (SECRET_STATE_KEYS at packages/types/src/global-settings.ts:362-398, SecretState at :410), and ClineProvider.getValues() merges the view buffer over the shared values at src/core/webview/ClineProvider.ts:4512, so a restored or edited profile carried its key through the public API for any extension holding it. The nested configuration is now filtered with the same predicate the top level uses, and the merged object is returned untouched when there is nothing to strip, so readers that compare identity are not disturbed. Review row 4509495968. getState() resolved mode from the view buffer and the profile from shared state: the only viewLocalState reference in its body was the mode line, while apiConfiguration came from getProviderSettings() and currentApiConfigName from stateValues. An idle second view therefore displayed - and started tasks with - the profile the last committing view activated. Both fields now resolve the pinned pair first and fall back to the shared pair when this view holds no pin. Review row 4509495951, second finding. Legs on this tree: prettier --check . exits 0 ("All matched files use Prettier code style!"); eslint --prune-suppressions --max-warnings=0 over the four touched files exits 0 and left src/eslint-suppressions.json canonical-identical (265 entries, 26,403 bytes) after re-serialising it twice, so both re-serialisations were reverted and no count moved upward; pnpm --dir src run check-types exits 0 with zero error rows. vitest run extension/__tests__/api-configuration.spec.ts is 11/11 passing, and vitest run ClineProvider is 643/643 passing across 13 files. Negative controls, one fix removed at a time, so the two fixes are shown to be load-bearing rather than present: with src/extension/api.ts back at its previous body, "strips provider secrets nested inside the configuration it hands out" fails at src/extension/__tests__/api-configuration.spec.ts:87 on expect(configuration.apiConfiguration).toEqual(...) (1 failed, 10 passed); with src/core/webview/ClineProvider.ts back at its previous body, "keeps the restored profile visible to public readers when the shared store names another profile" fails at src/core/webview/__tests__/ClineProvider.spec.ts:6964 on expect(state.currentApiConfigName).toBe("my-profile") (1 failed, 403 passed). The pins at ClineProvider.spec.ts:6962-6970 are deliberately flipped from the shared pair to the pinned pair, and the reviewer ask on row 4509495951 is what justifies the flip. No changeset, no changelog entry. --- src/core/webview/ClineProvider.ts | 14 +++- .../webview/__tests__/ClineProvider.spec.ts | 25 +++++-- .../__tests__/api-configuration.spec.ts | 74 ++++++++++++++++++- src/extension/api.ts | 26 ++++++- 4 files changed, 128 insertions(+), 11 deletions(-) diff --git a/src/core/webview/ClineProvider.ts b/src/core/webview/ClineProvider.ts index 5b2d450c73..9b33248f20 100644 --- a/src/core/webview/ClineProvider.ts +++ b/src/core/webview/ClineProvider.ts @@ -4370,6 +4370,16 @@ export class ClineProvider providerSettings.apiProvider = apiProvider } + // The profile pair this view restored or edited lives in its own buffer: loadViewState seeds it + // from the pinned profile, and every per-view write merges into it. The shared store only carries + // the pair the last committing view activated, so returning that here would let an idle view + // display and start tasks with a profile it never picked. Return this view's pair, and fall back + // to the shared pair when this view holds no pin - the rule the mode line below already follows + // for mode. + const viewApiConfiguration: ProviderSettings = this.viewLocalState.apiConfiguration ?? providerSettings + const viewApiConfigName = + this.viewLocalState.currentApiConfigName ?? stateValues.currentApiConfigName ?? "default" + let organizationAllowList = ORGANIZATION_ALLOW_ALL try { @@ -4421,7 +4431,7 @@ export class ClineProvider // Return the same structure as before. return { - apiConfiguration: providerSettings, + apiConfiguration: viewApiConfiguration, lastShownAnnouncementId: stateValues.lastShownAnnouncementId, customInstructions: stateValues.customInstructions, apiModelId: stateValues.apiModelId, @@ -4477,7 +4487,7 @@ export class ClineProvider language: stateValues.language ?? formatLanguage(vscode.env.language), mcpEnabled: stateValues.mcpEnabled ?? true, mcpServers: this.mcpHub?.getAllServers() ?? [], - currentApiConfigName: stateValues.currentApiConfigName ?? "default", + currentApiConfigName: viewApiConfigName, listApiConfigMeta: stateValues.listApiConfigMeta ?? [], pinnedApiConfigs: stateValues.pinnedApiConfigs ?? {}, modeApiConfigs: stateValues.modeApiConfigs ?? ({} as Record), diff --git a/src/core/webview/__tests__/ClineProvider.spec.ts b/src/core/webview/__tests__/ClineProvider.spec.ts index d37632dea7..a3706b86c1 100644 --- a/src/core/webview/__tests__/ClineProvider.spec.ts +++ b/src/core/webview/__tests__/ClineProvider.spec.ts @@ -7527,15 +7527,26 @@ describe("ClineProvider", () => { apiProvider: providerIdentifiers.openrouter, openRouterModelId: "model-x", }) - // Public reader 2: getState() and the state posted to the webview still resolve the - // shared profile, while the mode they report is already the view-local one. That split is - // what row 4509495951 asks to close; pinning both sides here makes the fix flip a visible - // assertion instead of passing unnoticed. + // Public reader 2: getState() and the state posted to the webview resolve the pinned pair + // belonging to this view rather than the pair the shared store carries, because task creation + // and the webview read these fields. Row 4509495951 asked for exactly this, and these are the + // assertions that flip when it lands; the mode line is asserted beside them to show that the + // two now agree. const state = await provider.getState() - expect(state.currentApiConfigName).toBe("shared-profile") - expect(state.apiConfiguration).toMatchObject({ apiProvider: providerIdentifiers.anthropic }) + expect(state.currentApiConfigName).toBe("my-profile") + expect(state.apiConfiguration).toEqual({ + apiProvider: providerIdentifiers.openrouter, + openRouterModelId: "model-x", + }) expect(state.mode).toBe("architect") - expect((await provider.getStateToPostToWebview()).currentApiConfigName).toBe("shared-profile") + expect((await provider.getStateToPostToWebview()).currentApiConfigName).toBe("my-profile") + // Fallback half of the rule: once this view stops pinning, readers get the shared pair again, + // so the fix cannot strand a view that never picked a profile. + await provider.saveViewState("apiConfiguration", undefined) + await provider.saveViewState("currentApiConfigName", undefined) + const afterClear = await provider.getState() + expect(afterClear.currentApiConfigName).toBe("shared-profile") + expect(afterClear.apiConfiguration).toMatchObject({ apiProvider: providerIdentifiers.anthropic }) await provider.dispose() }) diff --git a/src/extension/__tests__/api-configuration.spec.ts b/src/extension/__tests__/api-configuration.spec.ts index 6f263ab9f6..ba88106237 100644 --- a/src/extension/__tests__/api-configuration.spec.ts +++ b/src/extension/__tests__/api-configuration.spec.ts @@ -1,7 +1,7 @@ import { describe, expect, it, vi } from "vitest" import type * as vscode from "vscode" -import type { RooCodeSettings } from "@roo-code/types" +import { providerIdentifiers, type ProviderSettings, type RooCodeSettings } from "@roo-code/types" import { API } from "../api" import type { ClineProvider } from "../../core/webview/ClineProvider" @@ -47,6 +47,78 @@ describe("API - configuration", () => { expect(postStateToWebview).toHaveBeenCalledOnce() }) + it("strips provider secrets nested inside the configuration it hands out", () => { + const apiConfiguration: ProviderSettings = { + apiProvider: providerIdentifiers.openrouter, + openRouterModelId: "model-x", + openRouterBaseUrl: "https://example.test/v1", + openRouterApiKey: "nested-secret-value", + } + const getValues = vi.fn().mockReturnValue({ + currentApiConfigName: "my-profile", + apiConfiguration, + openRouterApiKey: "top-level-secret", + openAiApiKey: "second-top-level-secret", + alwaysAllowReadOnly: true, + }) + const provider = { + context: {}, + on: vi.fn(), + log: vi.fn(), + getValues, + contextProxy: { setValues: vi.fn().mockResolvedValue(undefined) }, + providerSettingsManager: { saveConfig: vi.fn(), setModeConfig: vi.fn() }, + postStateToWebview: vi.fn().mockResolvedValue(undefined), + } as unknown as ClineProvider + const outputChannel = { appendLine: vi.fn() } as unknown as vscode.OutputChannel + const api = new API(outputChannel, provider, makeClineProviderFactory()) + + // The public signature says RooCodeSettings; the runtime value also carries the view profile + // buffer under apiConfiguration, which is what this test is about. + const configuration: RooCodeSettings & { apiConfiguration?: ProviderSettings } = api.getConfiguration() + + // The names filtered here are names a profile carries: SECRET_STATE_KEYS are keys of + // ProviderSettings (SecretState in packages/types/src/global-settings.ts), so a profile saved with + // one of them used to be readable through the public API even though the top-level key of the same + // name was filtered out. + expect(configuration["openRouterApiKey"]).toBeUndefined() + expect(configuration["openAiApiKey"]).toBeUndefined() + expect(configuration.alwaysAllowReadOnly).toBe(true) + expect(configuration.currentApiConfigName).toBe("my-profile") + expect(configuration.apiConfiguration).toEqual({ + apiProvider: providerIdentifiers.openrouter, + openRouterModelId: "model-x", + openRouterBaseUrl: "https://example.test/v1", + }) + expect(JSON.stringify(configuration.apiConfiguration)).not.toContain("nested-secret-value") + expect(getValues).toHaveBeenCalledOnce() + }) + + it("hands back the same nested configuration object when it holds no secret", () => { + const apiConfiguration: ProviderSettings = { + apiProvider: providerIdentifiers.openrouter, + openRouterModelId: "model-x", + } + const getValues = vi.fn().mockReturnValue({ currentApiConfigName: "my-profile", apiConfiguration }) + const provider = { + context: {}, + on: vi.fn(), + log: vi.fn(), + getValues, + contextProxy: { setValues: vi.fn().mockResolvedValue(undefined) }, + providerSettingsManager: { saveConfig: vi.fn(), setModeConfig: vi.fn() }, + postStateToWebview: vi.fn().mockResolvedValue(undefined), + } as unknown as ClineProvider + const outputChannel = { appendLine: vi.fn() } as unknown as vscode.OutputChannel + const api = new API(outputChannel, provider, makeClineProviderFactory()) + + const configuration: RooCodeSettings & { apiConfiguration?: ProviderSettings } = api.getConfiguration() + + // A reader comparing the configuration it received against the object the provider holds is not + // disturbed by a call that had nothing to strip. + expect(configuration.apiConfiguration).toBe(apiConfiguration) + }) + 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 15be22d774..b4f7929d34 100644 --- a/src/extension/api.ts +++ b/src/extension/api.ts @@ -636,9 +636,33 @@ export class API extends EventEmitter implements RooCodeAPI { // Global Settings Management public getConfiguration(): RooCodeSettings { - return Object.fromEntries( + const values = Object.fromEntries( Object.entries(this.sidebarProvider.getValues()).filter(([key]) => !isSecretStateKey(key)), ) + const apiConfiguration = values.apiConfiguration + // The secret storage keys are keys of ProviderSettings (SecretState in + // packages/types/src/global-settings.ts), so a profile-shaped value can carry a secret that the + // top-level filter above cannot see: getValues() merges this view's restored apiConfiguration, + // and any extension holding the API could read a key that a profile happened to save. Strip the + // nested secrets, and hand the merged object back untouched when there is nothing to strip, so + // readers that compare identity are not disturbed. A value that is absent, a primitive, or an + // array is not a profile-shaped object and is left alone. + if (!apiConfiguration || typeof apiConfiguration !== "object" || Array.isArray(apiConfiguration)) { + return values + } + const visibleApiConfiguration = Object.fromEntries( + Object.entries(apiConfiguration).filter(([key]) => !isSecretStateKey(key)), + ) + // Nothing was stripped when the key counts agree, so hand back the merged object untouched; + // otherwise put the filtered profile back in place of the original one. + if (Object.keys(visibleApiConfiguration).length === Object.keys(apiConfiguration).length) { + return values + } + return Object.fromEntries( + Object.entries(values).map(([key, value]) => + key === "apiConfiguration" ? [key, visibleApiConfiguration] : [key, value], + ), + ) } /** From 93b2c5c83609279907a870230371480b93010767 Mon Sep 17 00:00:00 2001 From: easonLiangWorldedtech Date: Fri, 13 Nov 2026 16:31:44 +0800 Subject: [PATCH 37/42] Layer the view's pinned provider settings over the store's current settings getState returns this view's buffered apiConfiguration in place of the store's provider settings whenever the buffer holds one, so a mutation that moved the shared settings after the pin was written stayed invisible to every consumer. Layer the pin over the settings the store holds now instead of replacing them. Measured locally on a mocked footing at the merge base with this file and the three files it needs: 45 passing / 29 failing becomes 48 passing / 26 failing; three Roo Code Subtasks failures are taken and none is added. The mocked row is still red: 21 head-side failures remain beyond the five that also fail at the merge base, and the hosted row for this commit has not been read. --- src/core/webview/ClineProvider.ts | 5 ++++- 1 file changed, 4 insertions(+), 1 deletion(-) diff --git a/src/core/webview/ClineProvider.ts b/src/core/webview/ClineProvider.ts index 9b33248f20..441b58f2fb 100644 --- a/src/core/webview/ClineProvider.ts +++ b/src/core/webview/ClineProvider.ts @@ -4376,7 +4376,10 @@ export class ClineProvider // display and start tasks with a profile it never picked. Return this view's pair, and fall back // to the shared pair when this view holds no pin - the rule the mode line below already follows // for mode. - const viewApiConfiguration: ProviderSettings = this.viewLocalState.apiConfiguration ?? providerSettings + // The pin is this view's pair, but it must not mask a shared value the view never carried: + // layer it over the store's current settings rather than replacing them, so a mutation that + // moved the shared settings after the pin is still visible to every consumer of getState. + const viewApiConfiguration: ProviderSettings = { ...providerSettings, ...this.viewLocalState.apiConfiguration } const viewApiConfigName = this.viewLocalState.currentApiConfigName ?? stateValues.currentApiConfigName ?? "default" From 308036cea84070819eb7526123f3a949c32a01b9 Mon Sep 17 00:00:00 2001 From: easonLiangWorldedtech Date: Sat, 14 Nov 2026 03:53:36 +0800 Subject: [PATCH 38/42] test(e2e): clear the per-view pin and view-local buffer after each test A cancelTask rehydrate inside a suite writes the durable per-view profile pin and the view-local buffer, and the next suite then resolves the provider that pin points at instead of the one its own setup configured. RooCodeAPI exposes no door onto either one, so the mocked harness reaches the provider object the exports hand back and clears both after every test. --- apps/vscode-e2e/src/suite/index.ts | 9 +++++++- apps/vscode-e2e/src/suite/utils.ts | 33 ++++++++++++++++++++++++++++++ 2 files changed, 41 insertions(+), 1 deletion(-) diff --git a/apps/vscode-e2e/src/suite/index.ts b/apps/vscode-e2e/src/suite/index.ts index bcc229890c..c07d351dc5 100644 --- a/apps/vscode-e2e/src/suite/index.ts +++ b/apps/vscode-e2e/src/suite/index.ts @@ -6,7 +6,7 @@ import * as vscode from "vscode" import { RooCodeEventName, type RooCodeAPI } from "@roo-code/types" -import { isCompletedAsk, waitFor } from "./utils" +import { clearViewStateBetweenSuites, isCompletedAsk, waitFor } from "./utils" export async function run() { const extension = vscode.extensions.getExtension("ZooCodeOrganization.zoo-code") @@ -66,6 +66,13 @@ export async function run() { } const mocha = new Mocha(mochaOptions) + + // Clear the per-view pin and the view-local buffer after every test so each suite + // resolves the provider it configures itself; see clearViewStateBetweenSuites. + mocha.suite.afterEach(async () => { + await clearViewStateBetweenSuites(api) + }) + const cwd = path.resolve(__dirname, "..") let testFiles: string[] diff --git a/apps/vscode-e2e/src/suite/utils.ts b/apps/vscode-e2e/src/suite/utils.ts index c433916355..dc2bd64fd5 100644 --- a/apps/vscode-e2e/src/suite/utils.ts +++ b/apps/vscode-e2e/src/suite/utils.ts @@ -84,3 +84,36 @@ export const waitUntilCompleted = async ({ } export const sleep = (ms: number) => new Promise((resolve) => setTimeout(resolve, ms)) + +/** + * The per-view mode pin and the view-local buffer are cleared here because no public + * door on RooCodeAPI clears them: `cancelTask()` rehydrates the task from its history + * item, which writes both, and a later suite would otherwise resolve the provider that + * pin points at instead of the one its own setup configured. The two private clear + * helpers are read off the exports object through a widened alias and verified by a + * type guard, so a surface change fails loudly instead of silently skipping the clear. + */ +type ViewStateClearDoor = { + _clearViewLocalState?: () => void + clearPersistedViewState?: () => Promise + viewStateId?: string +} + +type ViewStateCarryingApi = RooCodeAPI & { sidebarProvider?: ViewStateClearDoor } + +const isViewStateClearDoor = (value: unknown): value is ViewStateClearDoor => + typeof value === "object" && value !== null && "_clearViewLocalState" in value && "clearPersistedViewState" in value + +export const clearViewStateBetweenSuites = async (api: RooCodeAPI): Promise => { + const provider = (api as ViewStateCarryingApi)["sidebarProvider"] + + if (!isViewStateClearDoor(provider)) { + console.log("[view-state-teardown] exports object carries no view-state clear door; nothing cleared") + return + } + + const viewStateId = typeof provider["viewStateId"] === "string" ? provider["viewStateId"] : "unset" + await provider["clearPersistedViewState"]?.() + provider["_clearViewLocalState"]?.() + console.log(`[view-state-teardown] cleared the persisted entry and the view-local buffer for viewId=${viewStateId}`) +} From 1fad4846bdd48c81588c3c3811e0328cad7d752c Mon Sep 17 00:00:00 2001 From: "user.email" <136036952+easonLiangWorldedtech@users.noreply.github.com> Date: Sat, 14 Nov 2026 15:03:15 +0800 Subject: [PATCH 39/42] fix(settings): order the profile-deletion writes and count secret writes where the rollback guard reads Delete-profile repair: install the surviving profile's settings before re-pointing a view that was pinned to the deleted profile, so a settings write that rejects can no longer leave the shared store naming the survivor while it still carries the deleted profile's settings. A pinned view is still re-pointed when nothing resolved to install. ContextProxy: advance the per-key write generation in storeSecret the way updateGlobalState does, and widen the map's key type across both stores, so ClineProvider#_restoreSharedValuesAfterFailedViewWrite can tell its own secret write from a newer write of the same secret value. Dropped the secret half of that guard's exemption - pass-through keys stay exempt - and the now-unused isSecretStateKey import. api: drop the per-view state record from getConfiguration() so an extension that holds the API configuration is not handed every view's buffer. Tests: the delete-profile half-repair, the per-key generation a rollback reads from a secret write, the guard against a newer same-valued secret write, and the record kept out of the configuration read. The existing secret-rollback case is renamed to say what it now proves. Rebased onto f2b4d1c0d24016f621e9aa77b3fcaca5ecca915c. Four hunks needed hand reconciliation and are nameable: the write-generation counter had to go back into updateGlobalState beside the trunk's write-owner machinery (the provider rollback reads it); the fire-and-forget post and the view-resolve html block came through twice and one copy of each was removed, the surviving post carrying the diagnostics records and the dropped-message log on both paths; the view-dispose registration came through twice and the copy kept is the one that clears the panel; and the mode-validation describe existed once on each side, so the trunk's copy was dropped and its two per-provider mode-to-profile mapping lines were folded into the copy kept, which asserts the view's own pin instead of the shared mode write the pre-rebase trunk asserted. The suppression registry lands two lines below the trunk tip's: the merged file carried 60 entries that neither parent had (left from the mid-replay state an entry-wise merge read) and two counts above what the merged tree contains. Measured with --prune-suppressions against a scratch copy of the registry, the shared file never pruned by the tool, the registry is the trunk tip's text with core/webview/__tests__/ClineProvider.spec.ts at 151 where the trunk side recorded 195 and core/webview/__tests__/ClineProvider.sticky-mode.spec.ts at 26 where it recorded 27 - both files this branch rewrites, both counts down, none up. eslint over the whole src project with no prune switch now exits 0 with no output. --- src/core/config/ContextProxy.ts | 11 +- .../config/__tests__/ContextProxy.spec.ts | 24 ++ src/core/webview/ClineProvider.ts | 69 +--- .../webview/__tests__/ClineProvider.spec.ts | 383 +++++------------- src/eslint-suppressions.json | 308 +------------- .../__tests__/api-configuration.spec.ts | 29 ++ src/extension/api.ts | 4 + 7 files changed, 195 insertions(+), 633 deletions(-) diff --git a/src/core/config/ContextProxy.ts b/src/core/config/ContextProxy.ts index 1ea3de7d58..97276b12b4 100644 --- a/src/core/config/ContextProxy.ts +++ b/src/core/config/ContextProxy.ts @@ -76,6 +76,8 @@ export class ContextProxy { private readonly originalContext: vscode.ExtensionContext private stateCache: GlobalState + // Counted for either store, so a rollback can tell its own write from a newer one of the same value. + private stateWriteGenerations = new Map() private secretCache: SecretState private _isInitialized = false @@ -420,6 +422,8 @@ export class ContextProxy { // writes that are in flight. An update that throws at once is turned into a rejection, so it is handled the same. const owner = {} this.stateWriteOwner.set(key, owner) + const generation = (this.stateWriteGenerations.get(key) ?? 0) + 1 + this.stateWriteGenerations.set(key, generation) this.stateCache[key] = value const release = () => { if (this.stateWriteOwner.get(key) === owner) this.stateWriteOwner.delete(key) @@ -436,8 +440,8 @@ export class ContextProxy { }) } - /** Current per-key write generation, used by callers whose rollback must not clobber a newer write. */ - public getStateWriteGeneration(key: K): number { + /** Current per-key write generation of either store: a rollback must not clobber a newer write. */ + public getStateWriteGeneration(key: K): number { return this.stateWriteGenerations.get(key) ?? 0 } @@ -466,6 +470,9 @@ export class ContextProxy { const owner = {} this.secretWriteOwner.set(key, owner) this.secretWriteCount.set(key, (this.secretWriteCount.get(key) ?? 0) + 1) + // Counted here as well as in updateGlobalState: the guard that rolls back a failed per-view write reads + // this map, and a secret it cannot count is a secret whose newer same-valued write it cannot see. + this.stateWriteGenerations.set(key, (this.stateWriteGenerations.get(key) ?? 0) + 1) this.secretCache[key] = value // Write directly to context. If the write rejects, the cache is read back from the secret storage while this diff --git a/src/core/config/__tests__/ContextProxy.spec.ts b/src/core/config/__tests__/ContextProxy.spec.ts index e86c5fb2c5..f01ee98e81 100644 --- a/src/core/config/__tests__/ContextProxy.spec.ts +++ b/src/core/config/__tests__/ContextProxy.spec.ts @@ -231,6 +231,14 @@ describe("ContextProxy", () => { }) it("should restore the last persisted value when two overlapping writes both reject", async () => { + // The fake now models storage: an update commits its value and a read sees what storage holds, + // which is what the cache correction on a rejected write reads back. A write that rejects + // commits nothing, so storage still holds the last value it accepted. + const storage = new Map() + mockGlobalState.get.mockImplementation((key: string) => storage.get(key)) + mockGlobalState.update.mockImplementation(async (key: string, value: unknown) => { + storage.set(key, value) + }) await proxy.updateGlobalState("apiProvider", "anthropic") mockGlobalState.update.mockReset() let rejectFirst: (error: Error) => void = () => {} @@ -393,6 +401,22 @@ describe("ContextProxy", () => { expect(storedValue).toBe("new-secret") }) + it("counts a secret write in the per-key generation a rollback reads", async () => { + const before = proxy.getStateWriteGeneration("apiKey") + + await proxy.storeSecret("apiKey", "first-secret") + + // The guard that rolls back a failed per-view write reads this counter, so a secret it cannot + // count is a secret whose newer write of the same value it cannot tell from its own. + expect(proxy.getStateWriteGeneration("apiKey")).toBe(before + 1) + + await proxy.storeSecret("apiKey", "first-secret") + + // A second write of the very same value moves the counter too: the value alone cannot tell the + // two apart. + expect(proxy.getStateWriteGeneration("apiKey")).toBe(before + 2) + }) + it("should handle undefined value for secret deletion", async () => { await proxy.storeSecret("apiKey", undefined) diff --git a/src/core/webview/ClineProvider.ts b/src/core/webview/ClineProvider.ts index 441b58f2fb..6d497893a3 100644 --- a/src/core/webview/ClineProvider.ts +++ b/src/core/webview/ClineProvider.ts @@ -76,7 +76,6 @@ import { modelIdKeys, providerIdentifiers, PROVIDER_SETTINGS_KEYS, - isSecretStateKey, } from "@roo-code/types" import { RateLimitClock, createRateLimitClock } from "../task/RateLimitClock" import { TaskRegistry } from "../task/TaskRegistry" @@ -1763,31 +1762,6 @@ export class ClineProvider this.webviewDisposables, ) - // Register disposal before awaiting HTML or state so closing the view during - // either load invalidates this resolve and prevents later listener installation. - webviewView.onDidDispose( - async () => { - // A view that is no longer current must not clear the current - // view's resources or dispose the provider. - if (webviewView !== this.view) { - return - } - - if (inTabMode) { - this.log("Disposing ClineProvider instance for tab view") - await this.dispose() - } else { - this.log("Clearing webview resources for sidebar view") - this.view = undefined - this.clearWebviewResources() - } - }, - null, - // View-scoped, like the other view subscriptions: disposed both when - // the view is disposed and when a different view replaces it. - this.webviewDisposables, - ) - if (inTabMode) { setPanel(webviewView, "tab") } else if ("onDidChangeVisibility" in webviewView) { @@ -1817,14 +1791,6 @@ export class ClineProvider webviewView.webview.html = html - // The HTML load above can finish after the view was disposed or replaced. - // A stale resolve must not assign HTML to a view the provider no longer owns. - if (this.isStaleViewResolve(webviewView)) { - return - } - - webviewView.webview.html = html - // Initialize out-of-scope variables that need to receive persistent // global state values. await this.getState().then( @@ -2357,7 +2323,6 @@ export class ClineProvider `[postMessageToWebview] dropped message type=${message.type}: ${error instanceof Error ? error.message : String(error)}`, ) } - try { try { void Promise.resolve(webview.postMessage(omitOriginalContentFromExtensionMessage(message))) .then((delivered) => { @@ -2383,7 +2348,6 @@ export class ClineProvider }) logDropped(error) } - } } public requestWebviewThemeFixture(timeoutMs = 5_000): Promise { @@ -3203,12 +3167,7 @@ export class ClineProvider } } - if (viewWasPinnedToDeleted) { - // This view's pin now dangles: re-point it. setValue also persists the - // survivor to the shared store, which covers the deleted-was-global case - // for every other view as well as this one. - await this.setValue("currentApiConfigName", profileToActivate) - } else if (deletedWasGlobal) { + if (deletedWasGlobal && !viewWasPinnedToDeleted) { // The shared selection changed, but this view's own pin still names a // surviving profile: update the shared store only, leaving the // view-local pin untouched. @@ -3223,6 +3182,14 @@ export class ClineProvider await this.contextProxy.setProviderSettings(survivingSettings) if (viewWasPinnedToDeleted) { + // This view's pin now dangles: re-point it only after the survivor's settings + // landed. A settings write that rejects propagates from the line above, so the + // shared store cannot be left naming the survivor while it still carries the + // deleted profile's settings - the half-repair this flow cannot undo. setValue + // also persists the survivor to the shared store, which covers the + // deleted-was-global case for every other view as well as this one. + await this.setValue("currentApiConfigName", profileToActivate) + // This view's nested overlay (viewLocalState.apiConfiguration, seeded // by loadViewState) still serves the deleted profile's configuration: // replace it with the survivor's so the re-pointed pin serves matching @@ -3238,6 +3205,9 @@ export class ClineProvider await this.persistStickyProviderProfileToCurrentTask(profileToActivate) } } else if (viewWasPinnedToDeleted) { + // Nothing resolved to install, so the pin still has to move off the deleted profile, + // and it moves before the overlay is cleared, in the order the re-pointed pin can serve. + await this.setValue("currentApiConfigName", profileToActivate) // The survivor's settings never resolved: this view's pin now names the survivor, so // its overlay must stop serving the deleted profile's configuration and fall back to // the shared settings instead. @@ -4670,7 +4640,7 @@ export class ClineProvider typeof sanitizedValues.mode !== "string" || !getModeBySlug(sanitizedValues.mode, await this.customModesManager.getCustomModes()) ) { - this.log(`[ClineProvider#setValues] Ignoring invalid mode "${String(sanitizedValues.mode)}"`) + this.log(`[ClineProvider#setValues] Ignoring invalid mode "${String(sanitizedValues.mode)}"`) delete sanitizedValues.mode } } @@ -6590,15 +6560,16 @@ export class ClineProvider for (const key of Object.keys(attempted) as (keyof RooCodeSettings)[]) { const generation = generations[key] - // ContextProxy does not count every key: secrets go through storeSecret and pass-through - // keys straight to the Memento, and neither advances the per-key write generation, so the - // expectation this setter recorded for them (generation 1 against a stored 0) can never - // match and would exempt those keys from the rollback of their own failed attempt. - const uncountedHere = isSecretStateKey(key) || isPassThroughStateKey(key) + // Pass-through keys go straight to the Memento and advance no per-key write generation, so the + // expectation this setter recorded for them (generation 1 against a stored 0) can never match; + // they are exempt from the generation test alone, not from the rollback of their own failed + // attempt. Secrets are counted, in storeSecret as in updateGlobalState, so a newer write of the + // same secret value is visible here and no longer rolls back over it. + const passThroughHere = isPassThroughStateKey(key) if ( this.contextProxy.getValue(key) === attempted[key] && (generation === undefined || - uncountedHere || + passThroughHere || this.contextProxy.getStateWriteGeneration(key as never) === generation) ) { ;(rollback as Record)[key] = previous[key] diff --git a/src/core/webview/__tests__/ClineProvider.spec.ts b/src/core/webview/__tests__/ClineProvider.spec.ts index a3706b86c1..d6c94b76fd 100644 --- a/src/core/webview/__tests__/ClineProvider.spec.ts +++ b/src/core/webview/__tests__/ClineProvider.spec.ts @@ -32,7 +32,7 @@ import { defaultModeSlug } from "../../../shared/modes" import { experimentDefault } from "../../../shared/experiments" import { setTtsEnabled } from "../../../utils/tts" import { ContextProxy } from "../../config/ContextProxy" -import { ProviderSettingsManager, ProviderSettingsNotFoundError } from "../../config/ProviderSettingsManager" +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" @@ -5747,6 +5747,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 @@ -5903,6 +5904,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 @@ -5993,6 +5995,56 @@ describe("ClineProvider", () => { await provider.dispose() }) + it("keeps the shared selection on the deleted profile when the survivor's settings cannot be installed", async () => { + const contextProxy = new ContextProxy(mockContext) + const deleter = new ClineProvider( + mockContext, + mockOutputChannel, + "sidebar", + contextProxy, + new WebviewFocusTracker(), + ) + const profileToDelete: ProviderSettingsEntry = { name: "deleted", id: "deleted-id" } + const deletedSettings = { apiProvider: providerIdentifiers.openrouter, openRouterModelId: "deleted-model" } + + await contextProxy.setValue("listApiConfigMeta", [ + { name: "deleted", id: "deleted-id" }, + { name: "survivor", id: "survivor-id" }, + ]) + await contextProxy.setValue("currentApiConfigName", "deleted") + await contextProxy.setProviderSettings(deletedSettings) + // This view's own pin names the profile being deleted. + await deleter.saveViewState("currentApiConfigName", "deleted") + + vi.spyOn(deleter["providerSettingsManager"], "deleteConfig").mockResolvedValue(undefined) + vi.spyOn(deleter["providerSettingsManager"], "activateProfile").mockResolvedValue({ + name: "survivor", + id: "survivor-id", + apiProvider: providerIdentifiers.anthropic, + }) + // The survivor's settings do resolve here, so the flow reaches the shared settings write - and + // that write is what fails. + vi.spyOn(deleter["providerSettingsManager"], "getProfile").mockResolvedValue({ + name: "survivor", + apiProvider: providerIdentifiers.anthropic, + }) + const settingsWrite = vi + .spyOn(deleter["contextProxy"], "setProviderSettings") + .mockRejectedValue(new Error("global store unavailable")) + + await expect(deleter.deleteProviderProfile(profileToDelete)).rejects.toThrow("global store unavailable") + + // The pinned name write must follow the survivor's settings write rather than precede it: with + // the settings write failed, the shared store may not already name the survivor while it still + // carries the deleted profile's settings - the half-repair nothing in this flow undoes. + expect(settingsWrite).toHaveBeenCalledOnce() + expect(deleter.getValue("currentApiConfigName")).toBe("deleted") + expect(deleter["viewLocalState"].currentApiConfigName).toBe("deleted") + expect(deleter.contextProxy.getProviderSettings()).toMatchObject(deletedSettings) + + await deleter.dispose() + }) + it("clears the settings overlay of a view re-pinned when the survivor's settings cannot be resolved", async () => { const contextProxy = new ContextProxy(mockContext) const deleter = new ClineProvider( @@ -6125,276 +6177,6 @@ describe("ClineProvider", () => { }) }) - describe("createTaskWithHistoryItem mode validation", () => { - test("validates and falls back to default mode when restored mode no longer exists", async () => { - await provider.resolveWebviewView(mockWebviewView) - - // Mock custom modes that don't include the saved mode - const mockCustomModesManager = { - getCustomModes: vi.fn().mockResolvedValue([ - { - slug: "existing-mode", - name: "Existing Mode", - roleDefinition: "Test role", - groups: ["read"] as const, - }, - ]), - dispose: vi.fn(), - } - ;(provider as any).customModesManager = mockCustomModesManager - - // Mock getModeBySlug to return undefined for non-existent mode - const { getModeBySlug } = await import("../../../shared/modes") - vi.mocked(getModeBySlug) - .mockReturnValueOnce(undefined) // First call returns undefined (mode doesn't exist) - .mockReturnValue({ - slug: "code", - name: "Code Mode", - roleDefinition: "You are a code assistant", - groups: ["read", "edit"], - }) // Subsequent calls return default mode - - // Mock provider settings manager - ;(provider as any).providerSettingsManager = { - getModeConfigId: vi.fn().mockResolvedValue(undefined), - listConfig: vi.fn().mockResolvedValue([]), - } - - // Spy on log method to verify warning was logged - const logSpy = vi.spyOn(provider, "log") - - // Create history item with non-existent mode - const historyItem = { - id: "test-id", - ts: Date.now(), - task: "Test task", - mode: "non-existent-mode", // This mode doesn't exist - number: 1, - tokensIn: 0, - tokensOut: 0, - totalCost: 0, - } - - // Initialize with history item - await provider.createTaskWithHistoryItem(historyItem) - - // Verify mode validation occurred - expect(mockCustomModesManager.getCustomModes).toHaveBeenCalled() - expect(getModeBySlug).toHaveBeenCalledWith("non-existent-mode", expect.any(Array)) - - // Verify fallback to default mode - expect(mockContext.globalState.update).toHaveBeenCalledWith("mode", "code") - expect(logSpy).toHaveBeenCalledWith( - "Mode 'non-existent-mode' from history no longer exists. Falling back to default mode 'code'.", - ) - - // Verify history item was updated with default mode - expect(historyItem.mode).toBe("code") - }) - - 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 - const mockCustomModesManager = { - getCustomModes: vi.fn().mockResolvedValue([ - { - slug: "custom-mode", - name: "Custom Mode", - roleDefinition: "Custom role", - groups: ["read", "edit"] as const, - }, - ]), - dispose: vi.fn(), - } - ;(provider as any).customModesManager = mockCustomModesManager - - // Mock getModeBySlug to return the custom mode - const { getModeBySlug } = await import("../../../shared/modes") - vi.mocked(getModeBySlug).mockReturnValue({ - slug: "custom-mode", - name: "Custom Mode", - roleDefinition: "Custom role", - groups: ["read", "edit"], - }) - - // Mock provider settings manager - ;(provider as any).providerSettingsManager = { - getModeConfigId: vi.fn().mockResolvedValue("config-id"), - listConfig: vi - .fn() - .mockResolvedValue([ - { name: "test-config", id: "config-id", apiProvider: providerIdentifiers.anthropic }, - ]), - activateProfile: vi.fn().mockResolvedValue({ - name: "test-config", - id: "config-id", - apiProvider: providerIdentifiers.anthropic, - }), - } - - // Spy on log method to verify no warning was logged - const logSpy = vi.spyOn(provider, "log") - - // Create history item with existing custom mode - const historyItem = { - id: "test-id", - ts: Date.now(), - task: "Test task", - mode: "custom-mode", - number: 1, - tokensIn: 0, - tokensOut: 0, - totalCost: 0, - } - - // Initialize with history item - await provider.createTaskWithHistoryItem(historyItem) - - // Verify mode validation occurred - expect(mockCustomModesManager.getCustomModes).toHaveBeenCalled() - expect(getModeBySlug).toHaveBeenCalledWith("custom-mode", expect.any(Array)) - - // Verify mode was preserved - expect(mockContext.globalState.update).toHaveBeenCalledWith("mode", "custom-mode") - expect(logSpy).not.toHaveBeenCalledWith(expect.stringContaining("no longer exists")) - - // Verify history item mode was not changed - expect(historyItem.mode).toBe("custom-mode") - }) - - test("preserves mode when it exists in built-in modes", async () => { - await provider.resolveWebviewView(mockWebviewView) - - // Mock no custom modes - const mockCustomModesManager = { - getCustomModes: vi.fn().mockResolvedValue([]), - dispose: vi.fn(), - } - ;(provider as any).customModesManager = mockCustomModesManager - - // Mock getModeBySlug to return built-in architect mode - const { getModeBySlug } = await import("../../../shared/modes") - vi.mocked(getModeBySlug).mockReturnValue({ - slug: "architect", - name: "Architect Mode", - roleDefinition: "You are an architect", - groups: ["read", "edit"], - }) - - // Mock provider settings manager - ;(provider as any).providerSettingsManager = { - getModeConfigId: vi.fn().mockResolvedValue(undefined), - listConfig: vi.fn().mockResolvedValue([]), - } - - // Create history item with built-in mode - const historyItem = { - id: "test-id", - ts: Date.now(), - task: "Test task", - mode: "architect", - number: 1, - tokensIn: 0, - tokensOut: 0, - totalCost: 0, - } - - // Initialize with history item - await provider.createTaskWithHistoryItem(historyItem) - - // Verify mode was preserved - expect(mockContext.globalState.update).toHaveBeenCalledWith("mode", "architect") - - // Verify history item mode was not changed - expect(historyItem.mode).toBe("architect") - }) - - test("handles history items without mode property", async () => { - await provider.resolveWebviewView(mockWebviewView) - - // Mock provider settings manager - ;(provider as any).providerSettingsManager = { - getModeConfigId: vi.fn().mockResolvedValue(undefined), - listConfig: vi.fn().mockResolvedValue([]), - } - - // Create history item without mode - const historyItem = { - id: "test-id", - ts: Date.now(), - task: "Test task", - // No mode property - number: 1, - tokensIn: 0, - tokensOut: 0, - totalCost: 0, - } - - // Initialize with history item - await provider.createTaskWithHistoryItem(historyItem) - - // Verify no mode validation occurred (mode update not called) - expect(mockContext.globalState.update).not.toHaveBeenCalledWith("mode", expect.any(String)) - }) - - 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 - const mockCustomModesManager = { - getCustomModes: vi.fn().mockResolvedValue([]), - dispose: vi.fn(), - } - ;(provider as any).customModesManager = mockCustomModesManager - - // Mock getModeBySlug to return built-in mode - const { getModeBySlug } = await import("../../../shared/modes") - vi.mocked(getModeBySlug).mockReturnValue({ - slug: "code", - name: "Code Mode", - roleDefinition: "You are a code assistant", - groups: ["read", "edit"], - }) - - // Mock provider settings manager to throw error - ;(provider as any).providerSettingsManager = { - getModeConfigId: vi.fn().mockResolvedValue("config-id"), - listConfig: vi - .fn() - .mockResolvedValue([ - { name: "test-config", id: "config-id", apiProvider: providerIdentifiers.anthropic }, - ]), - activateProfile: vi.fn().mockRejectedValue(new Error("Failed to load config")), - } - - // Spy on log method - const logSpy = vi.spyOn(provider, "log") - - // Create history item - const historyItem = { - id: "test-id", - ts: Date.now(), - task: "Test task", - mode: "code", - number: 1, - tokensIn: 0, - tokensOut: 0, - totalCost: 0, - } - - // Initialize with history item - should not throw - await expect(provider.createTaskWithHistoryItem(historyItem)).resolves.not.toThrow() - - // Verify error was logged but task restoration continued - expect(logSpy).toHaveBeenCalledWith( - expect.stringContaining("Failed to restore API configuration for mode 'code'"), - ) - }) - }) - describe("updateCustomMode", () => { test("updates both file and state when updating custom mode", async () => { await provider.resolveWebviewView(mockWebviewView) @@ -7913,7 +7695,7 @@ describe("ClineProvider", () => { mockContext.globalState.update = originalUpdate await provider.dispose() }) - it("should roll back a secret key that ContextProxy does not track with a write generation", async () => { + it("restores a secret whose own write is still the newest write of that key", async () => { const provider = new ClineProvider( mockContext, mockOutputChannel, @@ -7936,12 +7718,13 @@ describe("ClineProvider", () => { "storage unavailable", ) - // ContextProxy routes secret keys through storeSecret, which never advances the per-key - // write generation the rollback guard compares against. A key it does not count is captured - // with generation 1 and still reads 0 afterwards, so the guard excludes it and the secret - // alone stays at the value the failed attempt wrote while every other key is restored. - // The attempt did move the secret: ContextProxy.storeSecret is fire-and-forget, so - // only the presence of the attempted value and the restored end state are deterministic. + // storeSecret advances the per-key write generation the way updateGlobalState does, so the + // expectation this setter captured for the secret matches this attempt's own write and the + // secret comes back with every other key the attempt committed. What the guard will not do is + // restore over a newer write of the same value: that is the case below, which keeps the shape + // of the counted-key case beside it. The attempt did move the secret: storeSecret is + // fire-and-forget, so only the presence of the attempted value and the restored end state are + // deterministic. expect(secretStore.mock.calls.map(([key, value]) => [key, value])).toContainEqual([ "nanoGptApiKey", "new-secret", @@ -7953,6 +7736,50 @@ describe("ClineProvider", () => { await provider.dispose() }) + it("keeps the guard for a secret whose concurrent write carried the same value", async () => { + const provider = new ClineProvider( + mockContext, + mockOutputChannel, + "sidebar", + new ContextProxy(mockContext), + new WebviewFocusTracker(), + ) + await provider.contextProxy.setValue("nanoGptApiKey", "old-secret") + await provider.contextProxy.setValue("mode", "architect") + const originalUpdate = mockContext.globalState.update + let rejectViews: (error: Error) => void = () => {} + let viewWrites = 0 + mockContext.globalState.update = vi.fn().mockImplementation((key: string) => { + if (key === "viewStates") { + // The attempt's own per-view write is parked below; the concurrent write's must land. + viewWrites++ + if (viewWrites === 1) { + return new Promise((_, reject) => (rejectViews = reject)) + } + return Promise.resolve() + } + return Promise.resolve() + }) + + const attempt = provider.setValues({ nanoGptApiKey: "new-secret", mode: "code" }) + await vi.waitFor(() => expect(provider.contextProxy.getSecret("nanoGptApiKey")).toBe("new-secret")) + // A concurrent provider stores the very secret this attempt stored: the stored value cannot + // tell the two writes apart, only the per-key count can, and a secret the count did not carry + // is a secret the guard could not tell apart either. + await provider.contextProxy.setValue("nanoGptApiKey", "new-secret") + rejectViews(new Error("storage unavailable")) + await expect(attempt).rejects.toThrow("storage unavailable") + + // The rollback captured "old-secret". Restoring it here would undo a newer write this rollback + // did not make, for every view that reads shared state. The counted key this attempt really did + // leave newest is still restored, which is what the next assertion checks. + expect(provider.contextProxy.getSecret("nanoGptApiKey")).toBe("new-secret") + expect(provider.getValue("mode")).toBe("architect") + + mockContext.globalState.update = originalUpdate + await provider.dispose() + }) + it("should keep the generation guard for a counted key whose concurrent write carried the same value", async () => { const provider = new ClineProvider( mockContext, diff --git a/src/eslint-suppressions.json b/src/eslint-suppressions.json index c5b672fd4a..57c14e739b 100644 --- a/src/eslint-suppressions.json +++ b/src/eslint-suppressions.json @@ -1,89 +1,4 @@ { - "__mocks__/fs/promises.ts": { - "@typescript-eslint/no-explicit-any": { - "count": 4 - } - }, - "__tests__/ClineProvider.delegation.spec.ts": { - "@typescript-eslint/no-explicit-any": { - "count": 9 - } - }, - "__tests__/ClineProvider.history-resume-delegation.spec.ts": { - "@typescript-eslint/no-explicit-any": { - "count": 70 - } - }, - "__tests__/abandonSubtask.spec.ts": { - "@typescript-eslint/no-explicit-any": { - "count": 20 - } - }, - "__tests__/api-subtask.spec.ts": { - "@typescript-eslint/no-explicit-any": { - "count": 4 - } - }, - "__tests__/delegation-concurrent.spec.ts": { - "@typescript-eslint/no-explicit-any": { - "count": 6 - } - }, - "__tests__/delegation-events.spec.ts": { - "@typescript-eslint/no-explicit-any": { - "count": 6 - } - }, - "__tests__/migrateSettings.spec.ts": { - "@typescript-eslint/no-explicit-any": { - "count": 4 - } - }, - "__tests__/nested-delegation-resume.spec.ts": { - "@typescript-eslint/no-explicit-any": { - "count": 19 - } - }, - "__tests__/new-task-delegation.spec.ts": { - "@typescript-eslint/no-explicit-any": { - "count": 8 - } - }, - "activate/CodeActionProvider.ts": { - "@typescript-eslint/no-explicit-any": { - "count": 1 - } - }, - "activate/__tests__/CodeActionProvider.spec.ts": { - "@typescript-eslint/no-explicit-any": { - "count": 10 - } - }, - "activate/__tests__/handleUri.spec.ts": { - "@typescript-eslint/no-explicit-any": { - "count": 14 - } - }, - "activate/__tests__/registerCommands.spec.ts": { - "@typescript-eslint/no-explicit-any": { - "count": 2 - } - }, - "activate/registerCodeActions.ts": { - "@typescript-eslint/no-explicit-any": { - "count": 2 - } - }, - "activate/registerCommands.ts": { - "@typescript-eslint/no-explicit-any": { - "count": 1 - } - }, - "activate/registerTerminalActions.ts": { - "@typescript-eslint/no-explicit-any": { - "count": 1 - } - }, "api/providers/__tests__/anthropic-vertex.spec.ts": { "@typescript-eslint/no-explicit-any": { "count": 31 @@ -169,11 +84,6 @@ "count": 36 } }, - "api/providers/__tests__/lm-studio-timeout.spec.ts": { - "@typescript-eslint/no-explicit-any": { - "count": 3 - } - }, "api/providers/__tests__/mimo.spec.ts": { "@typescript-eslint/no-explicit-any": { "count": 18 @@ -409,11 +319,6 @@ "count": 3 } }, - "api/providers/qwen-code.ts": { - "@typescript-eslint/no-explicit-any": { - "count": 1 - } - }, "api/providers/requesty.ts": { "@typescript-eslint/no-explicit-any": { "count": 3 @@ -591,7 +496,7 @@ }, "core/checkpoints/__tests__/checkpoint.test.ts": { "@typescript-eslint/no-explicit-any": { - "count": 5 + "count": 3 } }, "core/checkpoints/index.ts": { @@ -811,12 +716,12 @@ }, "core/task/__tests__/ask-clear-approval-buttons.spec.ts": { "@typescript-eslint/no-explicit-any": { - "count": 19 + "count": 18 } }, "core/task/__tests__/ask-queued-message-drain.spec.ts": { "@typescript-eslint/no-explicit-any": { - "count": 18 + "count": 17 } }, "core/task/__tests__/flushPendingToolResultsToHistory.spec.ts": { @@ -1016,7 +921,7 @@ }, "core/webview/__tests__/ClineProvider.spec.ts": { "@typescript-eslint/no-explicit-any": { - "count": 195 + "count": 151 } }, "core/webview/__tests__/ClineProvider.sticky-mode.spec.ts": { @@ -1034,11 +939,6 @@ "count": 12 } }, - "core/webview/__tests__/checkpointRestoreHandler.spec.ts": { - "@typescript-eslint/no-explicit-any": { - "count": 3 - } - }, "core/webview/__tests__/diagnosticsHandler.spec.ts": { "@typescript-eslint/no-explicit-any": { "count": 7 @@ -1059,11 +959,6 @@ "count": 4 } }, - "core/webview/__tests__/webviewMessageHandler.checkpoint.spec.ts": { - "@typescript-eslint/no-explicit-any": { - "count": 5 - } - }, "core/webview/__tests__/webviewMessageHandler.cloudAuth.spec.ts": { "@typescript-eslint/no-explicit-any": { "count": 3 @@ -1114,146 +1009,6 @@ "count": 5 } }, - "extension/__tests__/api-delete-queued-message.spec.ts": { - "@typescript-eslint/no-explicit-any": { - "count": 1 - } - }, - "extension/__tests__/api-send-message.spec.ts": { - "@typescript-eslint/no-explicit-any": { - "count": 7 - } - }, - "extension/api.ts": { - "@typescript-eslint/no-explicit-any": { - "count": 9 - } - }, - "i18n/index.ts": { - "@typescript-eslint/no-explicit-any": { - "count": 1 - } - }, - "i18n/setup.ts": { - "@typescript-eslint/no-explicit-any": { - "count": 1 - } - }, - "integrations/editor/DiffViewProvider.ts": { - "@typescript-eslint/no-explicit-any": { - "count": 1 - } - }, - "integrations/editor/__tests__/DiffViewProvider.spec.ts": { - "@typescript-eslint/no-explicit-any": { - "count": 310 - } - }, - "integrations/editor/__tests__/EditorUtils.spec.ts": { - "@typescript-eslint/no-explicit-any": { - "count": 3 - } - }, - "integrations/kimi-code/__tests__/oauth.spec.ts": { - "@typescript-eslint/no-explicit-any": { - "count": 1 - } - }, - "integrations/misc/__tests__/export-markdown.spec.ts": { - "@typescript-eslint/no-explicit-any": { - "count": 1 - } - }, - "integrations/misc/__tests__/open-file.spec.ts": { - "@typescript-eslint/no-explicit-any": { - "count": 11 - } - }, - "integrations/misc/__tests__/performance/processCarriageReturns.benchmark.ts": { - "@typescript-eslint/no-explicit-any": { - "count": 2 - } - }, - "integrations/terminal/__tests__/ExecaTerminalProcess.spec.ts": { - "@typescript-eslint/no-explicit-any": { - "count": 10 - } - }, - "integrations/terminal/__tests__/OutputInterceptor.test.ts": { - "@typescript-eslint/no-explicit-any": { - "count": 5 - } - }, - "integrations/terminal/__tests__/TerminalProcess.spec.ts": { - "@typescript-eslint/no-explicit-any": { - "count": 7 - } - }, - "integrations/terminal/__tests__/TerminalProcess.test.ts": { - "@typescript-eslint/no-explicit-any": { - "count": 2 - } - }, - "integrations/terminal/__tests__/TerminalProcessExec.bash.spec.ts": { - "@typescript-eslint/no-explicit-any": { - "count": 2 - } - }, - "integrations/terminal/__tests__/TerminalProcessExec.cmd.spec.ts": { - "@typescript-eslint/no-explicit-any": { - "count": 1 - } - }, - "integrations/terminal/__tests__/TerminalProcessExec.pwsh.spec.ts": { - "@typescript-eslint/no-explicit-any": { - "count": 1 - } - }, - "integrations/terminal/__tests__/TerminalProcessInterpretExitCode.spec.ts": { - "@typescript-eslint/no-explicit-any": { - "count": 3 - } - }, - "integrations/terminal/__tests__/TerminalProfile.spec.ts": { - "@typescript-eslint/no-explicit-any": { - "count": 34 - } - }, - "integrations/terminal/__tests__/TerminalRegistry.spec.ts": { - "@typescript-eslint/no-explicit-any": { - "count": 22 - } - }, - "integrations/terminal/__tests__/setupTerminalTests.ts": { - "@typescript-eslint/no-explicit-any": { - "count": 1 - } - }, - "integrations/terminal/__tests__/streamUtils/bashStream.ts": { - "@typescript-eslint/no-explicit-any": { - "count": 1 - } - }, - "integrations/terminal/__tests__/streamUtils/cmdStream.ts": { - "@typescript-eslint/no-explicit-any": { - "count": 1 - } - }, - "integrations/terminal/__tests__/streamUtils/index.ts": { - "@typescript-eslint/no-explicit-any": { - "count": 2 - } - }, - "integrations/terminal/__tests__/streamUtils/pwshStream.ts": { - "@typescript-eslint/no-explicit-any": { - "count": 1 - } - }, - "integrations/theme/getTheme.ts": { - "@typescript-eslint/no-explicit-any": { - "count": 9 - } - }, "services/__tests__/zoo-code-auth.test.ts": { "@typescript-eslint/no-explicit-any": { "count": 3 @@ -1568,60 +1323,5 @@ "@typescript-eslint/no-explicit-any": { "count": 2 } - }, - "shared/__tests__/api.spec.ts": { - "@typescript-eslint/no-explicit-any": { - "count": 8 - } - }, - "shared/__tests__/embeddingModels.spec.ts": { - "@typescript-eslint/no-explicit-any": { - "count": 1 - } - }, - "shared/__tests__/modes-empty-prompt-component.spec.ts": { - "@typescript-eslint/no-explicit-any": { - "count": 1 - } - }, - "shared/api.ts": { - "@typescript-eslint/no-explicit-any": { - "count": 2 - } - }, - "shared/checkExistApiConfig.ts": { - "@typescript-eslint/no-explicit-any": { - "count": 1 - } - }, - "shared/cost.ts": { - "@typescript-eslint/no-explicit-any": { - "count": 1 - } - }, - "shared/parse-command.ts": { - "@typescript-eslint/no-explicit-any": { - "count": 1 - } - }, - "shared/support-prompt.ts": { - "@typescript-eslint/no-explicit-any": { - "count": 5 - } - }, - "shared/tools.ts": { - "@typescript-eslint/no-explicit-any": { - "count": 1 - } - }, - "shared/utils/__tests__/requesty.spec.ts": { - "@typescript-eslint/no-explicit-any": { - "count": 2 - } - }, - "vitest.setup.ts": { - "@typescript-eslint/no-explicit-any": { - "count": 1 - } } } diff --git a/src/extension/__tests__/api-configuration.spec.ts b/src/extension/__tests__/api-configuration.spec.ts index ba88106237..344066d2a7 100644 --- a/src/extension/__tests__/api-configuration.spec.ts +++ b/src/extension/__tests__/api-configuration.spec.ts @@ -119,6 +119,35 @@ describe("API - configuration", () => { expect(configuration.apiConfiguration).toBe(apiConfiguration) }) + it("keeps the per-view state record out of the configuration it hands out", () => { + const getValues = vi.fn().mockReturnValue({ + currentApiConfigName: "my-profile", + viewStates: { "view-a": { mode: "code" }, "view-b": { mode: "architect" } }, + alwaysAllowReadOnly: true, + }) + const provider = { + context: {}, + on: vi.fn(), + log: vi.fn(), + getValues, + contextProxy: { setValues: vi.fn().mockResolvedValue(undefined) }, + providerSettingsManager: { saveConfig: vi.fn(), setModeConfig: vi.fn() }, + postStateToWebview: vi.fn().mockResolvedValue(undefined), + } as unknown as ClineProvider + const outputChannel = { appendLine: vi.fn() } as unknown as vscode.OutputChannel + const api = new API(outputChannel, provider, makeClineProviderFactory()) + + const configuration = api.getConfiguration() + + // The record is this machine's map of every view's buffer, not a setting: an extension holding + // the API must not be handed it as configuration, and the rest of the settings bag still comes + // through unchanged. + expect(configuration).not.toHaveProperty("viewStates") + expect(configuration.currentApiConfigName).toBe("my-profile") + expect(configuration.alwaysAllowReadOnly).toBe(true) + expect(getValues).toHaveBeenCalledOnce() + }) + 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 b4f7929d34..a1e6f2a8bb 100644 --- a/src/extension/api.ts +++ b/src/extension/api.ts @@ -639,6 +639,10 @@ export class API extends EventEmitter implements RooCodeAPI { const values = Object.fromEntries( Object.entries(this.sidebarProvider.getValues()).filter(([key]) => !isSecretStateKey(key)), ) + // The per-view record is this machine's map of every view's buffer, not a setting: an extension + // holding the API must not be handed it as configuration, and dropping it here covers both the + // shared copy and the copy this view's buffer merged in. + delete values.viewStates const apiConfiguration = values.apiConfiguration // The secret storage keys are keys of ProviderSettings (SecretState in // packages/types/src/global-settings.ts), so a profile-shaped value can carry a secret that the From ae0c58bef02f0214045d683aaef51cdaa015ca94 Mon Sep 17 00:00:00 2001 From: "user.email" <136036952+easonLiangWorldedtech@users.noreply.github.com> Date: Sun, 15 Nov 2026 08:17:28 +0800 Subject: [PATCH 40/42] fix(webview): serve a pinned view's own profile configuration whole A view that pins a profile buffers that profile's settings, but getState() layered the shared store underneath the buffer, so a field the pinned profile does not carry was filled from whichever profile another view last activated. A task built in the pinned view then received this view's key together with the other view's OpenRouter endpoint, through createTask and createTaskWithHistoryItem. First half (read): a profile name plus a buffer stamped as read whole from that profile is a complete profile, so getState() serves such a pair as it is, and keeps layering a view's own edits over the store's current settings when the view holds no pair - no name, an overlay built by a partial provider edit, or a provider switch that replaced the overlay. Second half (edit): a partial provider edit is seeded from the configuration the view already serves, so editing one provider key keeps the fields of the profile the view pinned instead of depending on what the shared store happens to hold at read time. A patch that carries apiProvider still replaces the overlay wholesale and clears the pair, because the new provider's own keys are not a profile read whole. Test: two views over one shared store, asserting the apiConfiguration the Task double is constructed with. --- src/core/webview/ClineProvider.ts | 68 ++- ...lineProvider.pinnedProfileEndpoint.spec.ts | 503 ++++++++++++++++++ 2 files changed, 560 insertions(+), 11 deletions(-) create mode 100644 src/core/webview/__tests__/ClineProvider.pinnedProfileEndpoint.spec.ts diff --git a/src/core/webview/ClineProvider.ts b/src/core/webview/ClineProvider.ts index 6d497893a3..81a5a1a418 100644 --- a/src/core/webview/ClineProvider.ts +++ b/src/core/webview/ClineProvider.ts @@ -461,6 +461,15 @@ export class ClineProvider */ private viewLocalState: Partial = {} + /** + * The profile this view's buffered configuration was read whole from: the loadViewState seed, + * a profile activation, or a whole-configuration write. A name together with an overlay stamped + * for that same name is a complete profile rather than a partial patch, and getState() serves + * such a pair without borrowing absent fields from the shared store. Cleared whenever the + * overlay is dropped or replaced by a provider switch. + */ + private viewApiConfigurationProfileName?: string + // Bumped whenever the buffer is cleared (reset/import), so an in-flight load can tell // that its captured state was invalidated while it awaited the profile lookup. private viewLocalStateGeneration = 0 @@ -1148,6 +1157,16 @@ export class ClineProvider } this.viewLocalState = mergedState + // Stamp the pair only when the overlay is the one this lookup resolved. An overlay that an + // in-flight edit replaced above is this view's own patch rather than a profile read whole, and + // the name guard above deletes the overlay outright; neither carries a pair, so neither is + // stamped and getState() keeps layering them over the shared store as it does today. + this.viewApiConfigurationProfileName = + mergedState.apiConfiguration !== undefined && + mergedState.apiConfiguration === loadedState.apiConfiguration && + mergedState.currentApiConfigName === loadedState.currentApiConfigName + ? loadedState.currentApiConfigName + : undefined this.log(`[loadViewState] Loaded state for viewId ${this.viewId}`) } catch (error) { this.log( @@ -4346,10 +4365,22 @@ export class ClineProvider // display and start tasks with a profile it never picked. Return this view's pair, and fall back // to the shared pair when this view holds no pin - the rule the mode line below already follows // for mode. - // The pin is this view's pair, but it must not mask a shared value the view never carried: - // layer it over the store's current settings rather than replacing them, so a mutation that - // moved the shared settings after the pin is still visible to every consumer of getState. - const viewApiConfiguration: ProviderSettings = { ...providerSettings, ...this.viewLocalState.apiConfiguration } + // A pair - a profile name together with an overlay stamped as read whole from that profile - + // is this view's own configuration, so serve it as it is: an optional field the profile does not + // carry stays absent instead of picking up whatever the last committing view put in the shared + // store, which is how a pinned OpenRouter profile started tasks on another profile's endpoint. + // A view holding no pair - no name, an overlay built by a partial patch, or a provider switch that + // replaced the overlay - keeps layering its own edits over the store's current settings, so a + // shared mutation it never carried is still visible to it. + const pinnedViewApiConfiguration = + this.viewLocalState.currentApiConfigName !== undefined && + this.viewApiConfigurationProfileName === this.viewLocalState.currentApiConfigName + ? this.viewLocalState.apiConfiguration + : undefined + const viewApiConfiguration: ProviderSettings = pinnedViewApiConfiguration ?? { + ...providerSettings, + ...this.viewLocalState.apiConfiguration, + } const viewApiConfigName = this.viewLocalState.currentApiConfigName ?? stateValues.currentApiConfigName ?? "default" @@ -4712,6 +4743,7 @@ export class ClineProvider private _clearViewLocalState(): void { this.viewLocalStateGeneration += 1 this.viewLocalState = {} + this.viewApiConfigurationProfileName = undefined } // dev @@ -6520,8 +6552,13 @@ export class ClineProvider const val = values.apiConfiguration if (val === undefined || val === null) { delete this.viewLocalState.apiConfiguration + this.viewApiConfigurationProfileName = undefined } else { this.viewLocalState.apiConfiguration = val + // A whole-configuration write belongs to the name this view holds right now; an activation + // writes the profile's settings and its name together, so the stamp lands whichever of the + // two arrives last and a pair only forms when both have. + this.viewApiConfigurationProfileName = this.viewLocalState.currentApiConfigName } } else if (PROVIDER_SETTINGS_KEYS.some((key) => key in values)) { const providerSettingsUpdate = PROVIDER_SETTINGS_KEYS.reduce((acc, key) => { @@ -6532,13 +6569,22 @@ export class ClineProvider return acc }, {} as ProviderSettings) - this.viewLocalState.apiConfiguration = - "apiProvider" in providerSettingsUpdate - ? providerSettingsUpdate - : { - ...(this.viewLocalState.apiConfiguration ?? {}), - ...providerSettingsUpdate, - } + if ("apiProvider" in providerSettingsUpdate) { + // A provider change is not a partial edit: the patch replaces the overlay with the new + // provider's own keys, so the overlay is no longer a profile read whole and reads go back + // to layering it over the shared store. + this.viewApiConfigurationProfileName = undefined + this.viewLocalState.apiConfiguration = providerSettingsUpdate + } else { + // A partial provider edit is applied to the configuration this view already serves - its + // pinned profile's settings when it holds a pair - so editing one provider key cannot drop + // the fields that profile carries, and the stamp travels with the seeded overlay rather + // than being re-derived from the shared store on the next read. + this.viewLocalState.apiConfiguration = { + ...(this.viewLocalState.apiConfiguration ?? {}), + ...providerSettingsUpdate, + } + } } } diff --git a/src/core/webview/__tests__/ClineProvider.pinnedProfileEndpoint.spec.ts b/src/core/webview/__tests__/ClineProvider.pinnedProfileEndpoint.spec.ts new file mode 100644 index 0000000000..70d1d103b1 --- /dev/null +++ b/src/core/webview/__tests__/ClineProvider.pinnedProfileEndpoint.spec.ts @@ -0,0 +1,503 @@ +// npx vitest run core/webview/__tests__/ClineProvider.pinnedProfileEndpoint.spec.ts + +import * as vscode from "vscode" +import { WebviewFocusTracker } from "../WebviewFocusTracker" +import { makeCompositeDisposable } from "../../../test-utils/vscode" +import { TelemetryService } from "@roo-code/telemetry" +import { ClineProvider } from "../ClineProvider" +import { Task } from "../../task/Task" + +import { ContextProxy } from "../../config/ContextProxy" +import type { HistoryItem } from "@roo-code/types" +import { providerIdentifiers } from "@roo-code/types/provider-identifiers" +import { ORGANIZATION_ALLOW_ALL } from "@roo-code/types" + +vi.mock("vscode", () => ({ + ExtensionContext: vi.fn(), + OutputChannel: vi.fn(), + WebviewView: vi.fn(), + Disposable: { from: (...subscriptions: vscode.Disposable[]) => makeCompositeDisposable(...subscriptions) }, + Uri: { + joinPath: vi.fn(), + file: vi.fn(), + }, + CodeActionKind: { + QuickFix: { value: "quickfix" }, + RefactorRewrite: { value: "refactor.rewrite" }, + }, + commands: { + executeCommand: vi.fn().mockResolvedValue(undefined), + }, + window: { + showInformationMessage: vi.fn(), + showWarningMessage: vi.fn(), + showErrorMessage: vi.fn(), + onDidChangeActiveTextEditor: vi.fn(() => ({ dispose: vi.fn() })), + }, + workspace: { + getConfiguration: vi.fn().mockReturnValue({ + get: vi.fn().mockReturnValue([]), + update: vi.fn(), + }), + onDidChangeConfiguration: vi.fn().mockImplementation(() => { + return { + dispose: vi.fn(), + } + }), + onDidSaveTextDocument: vi.fn(() => ({ dispose: vi.fn() })), + onDidChangeTextDocument: vi.fn(() => ({ dispose: vi.fn() })), + onDidOpenTextDocument: vi.fn(() => ({ dispose: vi.fn() })), + onDidCloseTextDocument: vi.fn(() => ({ dispose: vi.fn() })), + }, + env: { + uriScheme: "vscode", + language: "en", + appName: "Visual Studio Code", + }, + ExtensionMode: { + Production: 1, + Development: 2, + Test: 3, + }, + version: "1.85.0", +})) + +// Create a counter for unique task IDs. +let taskIdCounter = 0 + +vi.mock("../../task/Task", () => ({ + Task: vi.fn().mockImplementation(function (options) { + return { + taskId: options.taskId || `test-task-id-${++taskIdCounter}`, + saveClineMessages: vi.fn(), + clineMessages: [], + apiConversationHistory: [], + overwriteClineMessages: vi.fn(), + overwriteApiConversationHistory: vi.fn(), + abortTask: vi.fn(), + handleWebviewAskResponse: vi.fn(), + getTaskNumber: vi.fn().mockReturnValue(0), + setTaskNumber: vi.fn(), + setParentTask: vi.fn(), + setRootTask: vi.fn(), + emit: vi.fn(), + parentTask: options.parentTask, + updateApiConfiguration: vi.fn(), + setTaskApiConfigName: vi.fn(), + _taskApiConfigName: options.historyItem?.apiConfigName, + taskApiConfigName: options.historyItem?.apiConfigName, + } + }), +})) + +vi.mock("../../prompts/sections/custom-instructions") + +vi.mock("../../../utils/safeWriteJson") + +vi.mock("../../../api", () => ({ + buildApiHandler: vi.fn().mockReturnValue({ + getModel: vi.fn().mockReturnValue({ + id: "claude-3-sonnet", + }), + }), +})) + +vi.mock("../../../integrations/workspace/WorkspaceTracker", () => ({ + default: vi.fn().mockImplementation(function () { + return { + initializeFilePaths: vi.fn(), + dispose: vi.fn(), + } + }), +})) + +vi.mock("../../diff/strategies/multi-search-replace", () => ({ + MultiSearchReplaceDiffStrategy: vi.fn().mockImplementation(function () { + return { + getName: () => "test-strategy", + applyDiff: vi.fn(), + } + }), +})) + +vi.mock("@roo-code/cloud", () => ({ + CloudService: { + hasInstance: vi.fn().mockReturnValue(true), + get instance() { + return { + isAuthenticated: vi.fn().mockReturnValue(false), + isCloudAgent: vi.fn().mockReturnValue(false), + getAllowList: vi.fn().mockResolvedValue(ORGANIZATION_ALLOW_ALL), + getUserInfo: vi.fn().mockReturnValue(undefined), + getOrganizationMemberships: vi.fn().mockReturnValue([]), + getOrganizationSettings: vi.fn().mockReturnValue(undefined), + logout: vi.fn().mockResolvedValue(undefined), + on: vi.fn(), + off: vi.fn(), + } + }, + }, + getRooCodeApiUrl: vi.fn().mockReturnValue("https://app.roocode.com"), +})) + +vi.mock("../../../shared/modes", () => ({ + modes: [ + { + slug: "code", + name: "Code Mode", + roleDefinition: "You are a code assistant", + groups: ["read", "edit"], + }, + { + slug: "architect", + name: "Architect Mode", + roleDefinition: "You are an architect", + groups: ["read", "edit"], + }, + ], + getModeBySlug: vi.fn().mockReturnValue({ + slug: "code", + name: "Code Mode", + roleDefinition: "You are a code assistant", + groups: ["read", "edit"], + }), + defaultModeSlug: "code", +})) + +vi.mock("../../prompts/system", () => ({ + SYSTEM_PROMPT: vi.fn().mockResolvedValue("mocked system prompt"), + codeMode: "code", +})) + +vi.mock("../../../api/providers/fetchers/modelCache", () => ({ + getModels: vi.fn().mockResolvedValue({}), + flushModels: vi.fn(), +})) + +vi.mock("../../../integrations/misc/extract-text", () => ({ + extractTextFromFile: vi.fn().mockResolvedValue("Mock file content"), +})) + +vi.mock("p-wait-for", () => ({ + default: vi.fn().mockImplementation(async () => Promise.resolve()), +})) + +vi.mock("fs/promises", () => ({ + mkdir: vi.fn().mockResolvedValue(undefined), + writeFile: vi.fn().mockResolvedValue(undefined), + readFile: vi.fn().mockResolvedValue(""), + readdir: vi.fn().mockResolvedValue([]), + unlink: vi.fn().mockResolvedValue(undefined), + rmdir: vi.fn().mockResolvedValue(undefined), + access: vi.fn().mockResolvedValue(undefined), + rm: vi.fn().mockResolvedValue(undefined), +})) + +vi.mock("../../../utils/storage", async (importOriginal) => { + const actual = await importOriginal() + return { + ...actual, + getStorageBasePath: vi.fn().mockImplementation((defaultPath: string) => { + return defaultPath + }), + getSettingsDirectoryPath: vi.fn().mockResolvedValue("/test/settings/path"), + getTaskDirectoryPath: vi.fn().mockResolvedValue("/test/task/path"), + } +}) + +vi.mock("@roo-code/telemetry", () => ({ + TelemetryService: { + hasInstance: vi.fn().mockReturnValue(true), + createInstance: vi.fn(), + get instance() { + return { + trackEvent: vi.fn(), + trackError: vi.fn(), + setProvider: vi.fn(), + captureModeSwitch: vi.fn(), + } + }, + }, +})) + +const VIEW_A_PROFILE = "view-a-openrouter" +const VIEW_B_PROFILE = "view-b-openrouter" +const VIEW_B_ENDPOINT = "https://router-b.example" + +const viewAProfileSettings = { + name: VIEW_A_PROFILE, + id: "view-a-id", + apiProvider: providerIdentifiers.openrouter, + openRouterApiKey: "view-a-key", + openRouterModelId: "view-a-model", +} + +const viewBProfileSettings = { + name: VIEW_B_PROFILE, + id: "view-b-id", + apiProvider: providerIdentifiers.openrouter, + openRouterApiKey: "view-b-key", + openRouterBaseUrl: VIEW_B_ENDPOINT, + openRouterModelId: "view-b-model", +} + +const profileEntries = [ + { name: VIEW_A_PROFILE, id: "view-a-id", apiProvider: providerIdentifiers.openrouter }, + { name: VIEW_B_PROFILE, id: "view-b-id", apiProvider: providerIdentifiers.openrouter }, +] + +// A history item that names neither a mode nor a profile: the restoration has no profile of its +// own to activate, so the task is built from whatever the restoring view is serving. +const HISTORY_ITEM_WITHOUT_PROFILE: HistoryItem = { + id: "endpoint-test-task", + number: 1, + ts: 1730000000000, + task: "restored task", + tokensIn: 0, + tokensOut: 0, + totalCost: 0, +} + +// A history item that names a mode: the restoration looks up that mode's saved profile and +// activates it, which re-pins the restoring view, so the task gets the mode's profile rather +// than the profile the view arrived with. +const HISTORY_ITEM_FOR_MODE: HistoryItem = { ...HISTORY_ITEM_WITHOUT_PROFILE, mode: "code" } + +/** Storage backing both views' proxies: one shared store, because the shared provider settings are + * extension-wide state and only the per-view buffers differ. */ +function makeBacking() { + const globalState: Record = { mode: "code", currentApiConfigName: "default-profile" } + const secrets: Record = {} + return { globalState, secrets } +} + +type Backing = ReturnType + +function makeContext(backing: Backing): vscode.ExtensionContext { + // Assertion: the double only needs the shape of the host context that ClineProvider and + // ContextProxy touch, which no exported type describes without the whole extension host. + return { + extensionPath: "/test/path", + extensionUri: { fsPath: "/test/path" } as vscode.Uri, + globalState: { + get: vi.fn().mockImplementation((key: string) => backing.globalState[key]), + update: vi.fn().mockImplementation((key: string, value: unknown) => { + backing.globalState[key] = value + return Promise.resolve() + }), + keys: vi.fn().mockImplementation(() => Object.keys(backing.globalState)), + }, + secrets: { + get: vi.fn().mockImplementation((key: string) => backing.secrets[key]), + store: vi.fn().mockImplementation((key: string, value: string | undefined) => { + backing.secrets[key] = value + return Promise.resolve() + }), + delete: vi.fn().mockImplementation((key: string) => { + delete backing.secrets[key] + return Promise.resolve() + }), + }, + workspaceState: { + get: vi.fn().mockReturnValue(undefined), + update: vi.fn().mockResolvedValue(undefined), + keys: vi.fn().mockReturnValue([]), + }, + subscriptions: [], + extension: { packageJSON: { version: "1.0.0" } }, + globalStorageUri: { fsPath: "/test/storage/path" }, + } as unknown as vscode.ExtensionContext +} + +function makeOutputChannel(): vscode.OutputChannel { + // Assertion: only the three methods the provider writes to are needed. + return { appendLine: vi.fn(), clear: vi.fn(), dispose: vi.fn() } as unknown as vscode.OutputChannel +} + +describe("ClineProvider - pinned profile endpoint isolation", () => { + let backing: Backing + let context: vscode.ExtensionContext + let views: ClineProvider[] + + beforeEach(() => { + vi.clearAllMocks() + taskIdCounter = 0 + if (!TelemetryService.hasInstance()) { + TelemetryService.createInstance([]) + } + backing = makeBacking() + context = makeContext(backing) + views = [] + }) + + afterEach(async () => { + const created = views + views = [] + await Promise.all(created.map((view) => view.dispose())) + }) + + async function makeView(renderContext: "sidebar" | "editor"): Promise { + const proxy = new ContextProxy(context) + // Production loads the proxy's caches during extension activation; a proxy that never + // initialized would read an empty store and could not see the shared settings at all. + await proxy.initialize() + const view = new ClineProvider(context, makeOutputChannel(), renderContext, proxy, new WebviewFocusTracker()) + await new Promise((resolve) => setTimeout(resolve, 10)) + view.getMcpHub = vi.fn().mockReturnValue({ + listTools: vi.fn().mockResolvedValue([]), + callTool: vi.fn().mockResolvedValue({ content: [] }), + listResources: vi.fn().mockResolvedValue([]), + readResource: vi.fn().mockResolvedValue({ contents: [] }), + getAllServers: vi.fn().mockReturnValue([]), + }) + vi.spyOn(view, "postStateToWebview").mockResolvedValue(undefined) + vi.spyOn(view.customModesManager, "getCustomModes").mockResolvedValue([]) + vi.spyOn(view.providerSettingsManager, "listConfig").mockResolvedValue(profileEntries) + views.push(view) + return view + } + + /** The view that commits the activation: it writes the shared store through the real + * activation path, so the pinned view only has to read what it left behind. */ + async function activatingView(): Promise { + const view = await makeView("sidebar") + vi.spyOn(view.providerSettingsManager, "getProfile").mockResolvedValue(viewBProfileSettings) + vi.spyOn(view.providerSettingsManager, "activateProfile").mockResolvedValue(viewBProfileSettings) + await view.activateProviderProfile({ name: VIEW_B_PROFILE }) + return view + } + + /** A view that pins its own profile: the persisted entry plus the profile lookup that + * loadViewState resolves it through, which is the pair a launched view restores. */ + async function pinnedView(): Promise { + const view = await makeView("editor") + vi.spyOn(view.providerSettingsManager, "getProfile").mockImplementation(async (params) => + "name" in params && params.name === VIEW_A_PROFILE ? viewAProfileSettings : viewBProfileSettings, + ) + await view["setViewStateId"]("stable-editor-view") + await view.contextProxy.setValue("viewStates", { + "stable-editor-view": { currentApiConfigName: VIEW_A_PROFILE, updatedAt: 1 }, + }) + await view["loadViewState"]() + return view + } + + /** Runs the task-creation path so that nothing after the Task constructor matters, while a + * failure that lands before the double was called still reaches the assertions. */ + async function runPastTaskConstruction(action: () => Promise): Promise { + try { + await action() + } catch (error) { + if (vi.mocked(Task).mock.calls.length === 0) { + throw error + } + } + } + + /** The configuration a task was actually constructed with, read off the Task double. */ + function configurationOfLastTask() { + const calls = vi.mocked(Task).mock.calls + const options = calls[calls.length - 1]?.[0] + if (!options) { + throw new Error("no task was constructed, so nothing was handed to Task") + } + return options.apiConfiguration + } + + it("starts a task on the pinned profile's own endpoint when another view activated one", async () => { + await activatingView() + const view = await pinnedView() + + await runPastTaskConstruction(() => view.createTask("hello", undefined, undefined, { startTask: false })) + + const apiConfiguration = configurationOfLastTask() + expect(apiConfiguration?.apiProvider).toBe(providerIdentifiers.openrouter) + expect(apiConfiguration?.openRouterApiKey).toBe("view-a-key") + expect(apiConfiguration?.openRouterModelId).toBe("view-a-model") + expect(apiConfiguration?.openRouterBaseUrl).toBeUndefined() + + const state = await view.getState() + expect(state.apiConfiguration?.openRouterBaseUrl).toBeUndefined() + expect(state.currentApiConfigName).toBe(VIEW_A_PROFILE) + + // The shared store really does carry the other view's endpoint: the assertion above is about + // this view not borrowing it, not about it never having been written. + expect((await (await makeView("sidebar")).getState()).apiConfiguration?.openRouterBaseUrl).toBe(VIEW_B_ENDPOINT) + }) + + it("restores a task that names no profile on the restoring view's own endpoint", async () => { + await activatingView() + const view = await pinnedView() + + await runPastTaskConstruction(() => + view.createTaskWithHistoryItem({ ...HISTORY_ITEM_WITHOUT_PROFILE }, { startTask: false }), + ) + + const apiConfiguration = configurationOfLastTask() + expect(apiConfiguration?.openRouterApiKey).toBe("view-a-key") + expect(apiConfiguration?.openRouterBaseUrl).toBeUndefined() + }) + + // A restored item that names a mode makes the restoration activate that mode's saved profile, + // which re-pins the restoring view. The task then gets that profile whole - never the pinned + // view's key welded onto the newly activated profile's endpoint. + it("restores a mode task on one profile's key and endpoint together", async () => { + await activatingView() + const view = await pinnedView() + + await runPastTaskConstruction(() => + view.createTaskWithHistoryItem({ ...HISTORY_ITEM_FOR_MODE }, { startTask: false }), + ) + + const apiConfiguration = configurationOfLastTask() + expect(apiConfiguration?.openRouterApiKey).toBe("view-b-key") + expect(apiConfiguration?.openRouterBaseUrl).toBe(VIEW_B_ENDPOINT) + expect((await view.getState()).currentApiConfigName).toBe(VIEW_B_PROFILE) + }) + + it("keeps the pinned profile's own fields when a partial provider edit is applied to it", async () => { + await activatingView() + const view = await pinnedView() + + await view.setValue("openRouterModelId", "edited-model") + + const overlay = view["viewLocalState"].apiConfiguration + expect(overlay?.openRouterApiKey).toBe("view-a-key") + expect(overlay?.openRouterModelId).toBe("edited-model") + expect(overlay?.openRouterBaseUrl).toBeUndefined() + + await runPastTaskConstruction(() => view.createTask("hello", undefined, undefined, { startTask: false })) + const apiConfiguration = configurationOfLastTask() + expect(apiConfiguration?.openRouterModelId).toBe("edited-model") + expect(apiConfiguration?.openRouterBaseUrl).toBeUndefined() + // The mechanism, named: the partial edit seeded from the pair this view holds rather than + // re-deriving the configuration from the shared store on the next read. + expect(view["viewApiConfigurationProfileName"]).toBe(VIEW_A_PROFILE) + }) + + // A provider change replaces the overlay wholesale, so this view stops holding a complete + // profile and reads go back to the shared store: the guard against treating a partial + // provider switch as if it were still the pinned profile's own configuration. + it("still layers a provider switch over the shared store instead of serving it alone", async () => { + await activatingView() + const view = await pinnedView() + + await view.setValues({ apiProvider: providerIdentifiers.anthropic, modelMaxTokens: 4321 }) + + const state = await view.getState() + expect(state.apiConfiguration?.apiProvider).toBe(providerIdentifiers.anthropic) + expect(state.apiConfiguration?.modelMaxTokens).toBe(4321) + expect(state.apiConfiguration?.openRouterBaseUrl).toBe(VIEW_B_ENDPOINT) + expect(view["viewApiConfigurationProfileName"]).toBeUndefined() + }) + + it("leaves a view that pins nothing reading the activated profile from the shared store", async () => { + await activatingView() + const view = await makeView("editor") + + const state = await view.getState() + expect(state.currentApiConfigName).toBe(VIEW_B_PROFILE) + expect(state.apiConfiguration?.openRouterBaseUrl).toBe(VIEW_B_ENDPOINT) + expect(state.apiConfiguration?.openRouterApiKey).toBe("view-b-key") + }) +}) From 0fe0694f91e4bf50377d9a654d5ee8124e5dd263 Mon Sep 17 00:00:00 2001 From: "user.email" <136036952+easonLiangWorldedtech@users.noreply.github.com> Date: Sun, 15 Nov 2026 12:00:45 +0800 Subject: [PATCH 41/42] test(e2e): name the starved predicate in the mocked e2e waitFor timeout Diagnostic only, no shipped behaviour changes. The mocked e2e leg failed on two rows, "abandoning an interrupted subtask severs the parent-child link" and "resumeTask on an interrupted standalone task presents resume_task ask and completes", and each ended with Error: Timeout after 30s printed from out/suite/utils.js with no caller frame, so the log cannot say which wait starved. The rejection now carries the predicate it was waiting on, keeping the Timeout after prefix and the seconds so existing greps still match. This is not a claim that the failure cause is settled. --- apps/vscode-e2e/src/suite/utils.ts | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/apps/vscode-e2e/src/suite/utils.ts b/apps/vscode-e2e/src/suite/utils.ts index dc2bd64fd5..2b1f13650a 100644 --- a/apps/vscode-e2e/src/suite/utils.ts +++ b/apps/vscode-e2e/src/suite/utils.ts @@ -17,7 +17,7 @@ export const waitFor = ( const timeoutId = setTimeout(() => { settled = true if (intervalId) clearTimeout(intervalId) - reject(new Error(`Timeout after ${Math.floor(timeout / 1000)}s`)) + reject(new Error(`Timeout after ${Math.floor(timeout / 1000)}s on ${condition.toString().slice(0, 240)}`)) }, timeout) const cleanup = () => { From 0413d9160def6c738103934ca375b0f8347e0c96 Mon Sep 17 00:00:00 2001 From: "user.email" <136036952+easonLiangWorldedtech@users.noreply.github.com> Date: Sun, 15 Nov 2026 13:05:43 +0800 Subject: [PATCH 42/42] Revert "fix(webview): serve a pinned view's own profile configuration whole" This reverts commit ae0c58bef02f0214045d683aaef51cdaa015ca94. --- src/core/webview/ClineProvider.ts | 68 +-- ...lineProvider.pinnedProfileEndpoint.spec.ts | 503 ------------------ 2 files changed, 11 insertions(+), 560 deletions(-) delete mode 100644 src/core/webview/__tests__/ClineProvider.pinnedProfileEndpoint.spec.ts diff --git a/src/core/webview/ClineProvider.ts b/src/core/webview/ClineProvider.ts index 81a5a1a418..6d497893a3 100644 --- a/src/core/webview/ClineProvider.ts +++ b/src/core/webview/ClineProvider.ts @@ -461,15 +461,6 @@ export class ClineProvider */ private viewLocalState: Partial = {} - /** - * The profile this view's buffered configuration was read whole from: the loadViewState seed, - * a profile activation, or a whole-configuration write. A name together with an overlay stamped - * for that same name is a complete profile rather than a partial patch, and getState() serves - * such a pair without borrowing absent fields from the shared store. Cleared whenever the - * overlay is dropped or replaced by a provider switch. - */ - private viewApiConfigurationProfileName?: string - // Bumped whenever the buffer is cleared (reset/import), so an in-flight load can tell // that its captured state was invalidated while it awaited the profile lookup. private viewLocalStateGeneration = 0 @@ -1157,16 +1148,6 @@ export class ClineProvider } this.viewLocalState = mergedState - // Stamp the pair only when the overlay is the one this lookup resolved. An overlay that an - // in-flight edit replaced above is this view's own patch rather than a profile read whole, and - // the name guard above deletes the overlay outright; neither carries a pair, so neither is - // stamped and getState() keeps layering them over the shared store as it does today. - this.viewApiConfigurationProfileName = - mergedState.apiConfiguration !== undefined && - mergedState.apiConfiguration === loadedState.apiConfiguration && - mergedState.currentApiConfigName === loadedState.currentApiConfigName - ? loadedState.currentApiConfigName - : undefined this.log(`[loadViewState] Loaded state for viewId ${this.viewId}`) } catch (error) { this.log( @@ -4365,22 +4346,10 @@ export class ClineProvider // display and start tasks with a profile it never picked. Return this view's pair, and fall back // to the shared pair when this view holds no pin - the rule the mode line below already follows // for mode. - // A pair - a profile name together with an overlay stamped as read whole from that profile - - // is this view's own configuration, so serve it as it is: an optional field the profile does not - // carry stays absent instead of picking up whatever the last committing view put in the shared - // store, which is how a pinned OpenRouter profile started tasks on another profile's endpoint. - // A view holding no pair - no name, an overlay built by a partial patch, or a provider switch that - // replaced the overlay - keeps layering its own edits over the store's current settings, so a - // shared mutation it never carried is still visible to it. - const pinnedViewApiConfiguration = - this.viewLocalState.currentApiConfigName !== undefined && - this.viewApiConfigurationProfileName === this.viewLocalState.currentApiConfigName - ? this.viewLocalState.apiConfiguration - : undefined - const viewApiConfiguration: ProviderSettings = pinnedViewApiConfiguration ?? { - ...providerSettings, - ...this.viewLocalState.apiConfiguration, - } + // The pin is this view's pair, but it must not mask a shared value the view never carried: + // layer it over the store's current settings rather than replacing them, so a mutation that + // moved the shared settings after the pin is still visible to every consumer of getState. + const viewApiConfiguration: ProviderSettings = { ...providerSettings, ...this.viewLocalState.apiConfiguration } const viewApiConfigName = this.viewLocalState.currentApiConfigName ?? stateValues.currentApiConfigName ?? "default" @@ -4743,7 +4712,6 @@ export class ClineProvider private _clearViewLocalState(): void { this.viewLocalStateGeneration += 1 this.viewLocalState = {} - this.viewApiConfigurationProfileName = undefined } // dev @@ -6552,13 +6520,8 @@ export class ClineProvider const val = values.apiConfiguration if (val === undefined || val === null) { delete this.viewLocalState.apiConfiguration - this.viewApiConfigurationProfileName = undefined } else { this.viewLocalState.apiConfiguration = val - // A whole-configuration write belongs to the name this view holds right now; an activation - // writes the profile's settings and its name together, so the stamp lands whichever of the - // two arrives last and a pair only forms when both have. - this.viewApiConfigurationProfileName = this.viewLocalState.currentApiConfigName } } else if (PROVIDER_SETTINGS_KEYS.some((key) => key in values)) { const providerSettingsUpdate = PROVIDER_SETTINGS_KEYS.reduce((acc, key) => { @@ -6569,22 +6532,13 @@ export class ClineProvider return acc }, {} as ProviderSettings) - if ("apiProvider" in providerSettingsUpdate) { - // A provider change is not a partial edit: the patch replaces the overlay with the new - // provider's own keys, so the overlay is no longer a profile read whole and reads go back - // to layering it over the shared store. - this.viewApiConfigurationProfileName = undefined - this.viewLocalState.apiConfiguration = providerSettingsUpdate - } else { - // A partial provider edit is applied to the configuration this view already serves - its - // pinned profile's settings when it holds a pair - so editing one provider key cannot drop - // the fields that profile carries, and the stamp travels with the seeded overlay rather - // than being re-derived from the shared store on the next read. - this.viewLocalState.apiConfiguration = { - ...(this.viewLocalState.apiConfiguration ?? {}), - ...providerSettingsUpdate, - } - } + this.viewLocalState.apiConfiguration = + "apiProvider" in providerSettingsUpdate + ? providerSettingsUpdate + : { + ...(this.viewLocalState.apiConfiguration ?? {}), + ...providerSettingsUpdate, + } } } diff --git a/src/core/webview/__tests__/ClineProvider.pinnedProfileEndpoint.spec.ts b/src/core/webview/__tests__/ClineProvider.pinnedProfileEndpoint.spec.ts deleted file mode 100644 index 70d1d103b1..0000000000 --- a/src/core/webview/__tests__/ClineProvider.pinnedProfileEndpoint.spec.ts +++ /dev/null @@ -1,503 +0,0 @@ -// npx vitest run core/webview/__tests__/ClineProvider.pinnedProfileEndpoint.spec.ts - -import * as vscode from "vscode" -import { WebviewFocusTracker } from "../WebviewFocusTracker" -import { makeCompositeDisposable } from "../../../test-utils/vscode" -import { TelemetryService } from "@roo-code/telemetry" -import { ClineProvider } from "../ClineProvider" -import { Task } from "../../task/Task" - -import { ContextProxy } from "../../config/ContextProxy" -import type { HistoryItem } from "@roo-code/types" -import { providerIdentifiers } from "@roo-code/types/provider-identifiers" -import { ORGANIZATION_ALLOW_ALL } from "@roo-code/types" - -vi.mock("vscode", () => ({ - ExtensionContext: vi.fn(), - OutputChannel: vi.fn(), - WebviewView: vi.fn(), - Disposable: { from: (...subscriptions: vscode.Disposable[]) => makeCompositeDisposable(...subscriptions) }, - Uri: { - joinPath: vi.fn(), - file: vi.fn(), - }, - CodeActionKind: { - QuickFix: { value: "quickfix" }, - RefactorRewrite: { value: "refactor.rewrite" }, - }, - commands: { - executeCommand: vi.fn().mockResolvedValue(undefined), - }, - window: { - showInformationMessage: vi.fn(), - showWarningMessage: vi.fn(), - showErrorMessage: vi.fn(), - onDidChangeActiveTextEditor: vi.fn(() => ({ dispose: vi.fn() })), - }, - workspace: { - getConfiguration: vi.fn().mockReturnValue({ - get: vi.fn().mockReturnValue([]), - update: vi.fn(), - }), - onDidChangeConfiguration: vi.fn().mockImplementation(() => { - return { - dispose: vi.fn(), - } - }), - onDidSaveTextDocument: vi.fn(() => ({ dispose: vi.fn() })), - onDidChangeTextDocument: vi.fn(() => ({ dispose: vi.fn() })), - onDidOpenTextDocument: vi.fn(() => ({ dispose: vi.fn() })), - onDidCloseTextDocument: vi.fn(() => ({ dispose: vi.fn() })), - }, - env: { - uriScheme: "vscode", - language: "en", - appName: "Visual Studio Code", - }, - ExtensionMode: { - Production: 1, - Development: 2, - Test: 3, - }, - version: "1.85.0", -})) - -// Create a counter for unique task IDs. -let taskIdCounter = 0 - -vi.mock("../../task/Task", () => ({ - Task: vi.fn().mockImplementation(function (options) { - return { - taskId: options.taskId || `test-task-id-${++taskIdCounter}`, - saveClineMessages: vi.fn(), - clineMessages: [], - apiConversationHistory: [], - overwriteClineMessages: vi.fn(), - overwriteApiConversationHistory: vi.fn(), - abortTask: vi.fn(), - handleWebviewAskResponse: vi.fn(), - getTaskNumber: vi.fn().mockReturnValue(0), - setTaskNumber: vi.fn(), - setParentTask: vi.fn(), - setRootTask: vi.fn(), - emit: vi.fn(), - parentTask: options.parentTask, - updateApiConfiguration: vi.fn(), - setTaskApiConfigName: vi.fn(), - _taskApiConfigName: options.historyItem?.apiConfigName, - taskApiConfigName: options.historyItem?.apiConfigName, - } - }), -})) - -vi.mock("../../prompts/sections/custom-instructions") - -vi.mock("../../../utils/safeWriteJson") - -vi.mock("../../../api", () => ({ - buildApiHandler: vi.fn().mockReturnValue({ - getModel: vi.fn().mockReturnValue({ - id: "claude-3-sonnet", - }), - }), -})) - -vi.mock("../../../integrations/workspace/WorkspaceTracker", () => ({ - default: vi.fn().mockImplementation(function () { - return { - initializeFilePaths: vi.fn(), - dispose: vi.fn(), - } - }), -})) - -vi.mock("../../diff/strategies/multi-search-replace", () => ({ - MultiSearchReplaceDiffStrategy: vi.fn().mockImplementation(function () { - return { - getName: () => "test-strategy", - applyDiff: vi.fn(), - } - }), -})) - -vi.mock("@roo-code/cloud", () => ({ - CloudService: { - hasInstance: vi.fn().mockReturnValue(true), - get instance() { - return { - isAuthenticated: vi.fn().mockReturnValue(false), - isCloudAgent: vi.fn().mockReturnValue(false), - getAllowList: vi.fn().mockResolvedValue(ORGANIZATION_ALLOW_ALL), - getUserInfo: vi.fn().mockReturnValue(undefined), - getOrganizationMemberships: vi.fn().mockReturnValue([]), - getOrganizationSettings: vi.fn().mockReturnValue(undefined), - logout: vi.fn().mockResolvedValue(undefined), - on: vi.fn(), - off: vi.fn(), - } - }, - }, - getRooCodeApiUrl: vi.fn().mockReturnValue("https://app.roocode.com"), -})) - -vi.mock("../../../shared/modes", () => ({ - modes: [ - { - slug: "code", - name: "Code Mode", - roleDefinition: "You are a code assistant", - groups: ["read", "edit"], - }, - { - slug: "architect", - name: "Architect Mode", - roleDefinition: "You are an architect", - groups: ["read", "edit"], - }, - ], - getModeBySlug: vi.fn().mockReturnValue({ - slug: "code", - name: "Code Mode", - roleDefinition: "You are a code assistant", - groups: ["read", "edit"], - }), - defaultModeSlug: "code", -})) - -vi.mock("../../prompts/system", () => ({ - SYSTEM_PROMPT: vi.fn().mockResolvedValue("mocked system prompt"), - codeMode: "code", -})) - -vi.mock("../../../api/providers/fetchers/modelCache", () => ({ - getModels: vi.fn().mockResolvedValue({}), - flushModels: vi.fn(), -})) - -vi.mock("../../../integrations/misc/extract-text", () => ({ - extractTextFromFile: vi.fn().mockResolvedValue("Mock file content"), -})) - -vi.mock("p-wait-for", () => ({ - default: vi.fn().mockImplementation(async () => Promise.resolve()), -})) - -vi.mock("fs/promises", () => ({ - mkdir: vi.fn().mockResolvedValue(undefined), - writeFile: vi.fn().mockResolvedValue(undefined), - readFile: vi.fn().mockResolvedValue(""), - readdir: vi.fn().mockResolvedValue([]), - unlink: vi.fn().mockResolvedValue(undefined), - rmdir: vi.fn().mockResolvedValue(undefined), - access: vi.fn().mockResolvedValue(undefined), - rm: vi.fn().mockResolvedValue(undefined), -})) - -vi.mock("../../../utils/storage", async (importOriginal) => { - const actual = await importOriginal() - return { - ...actual, - getStorageBasePath: vi.fn().mockImplementation((defaultPath: string) => { - return defaultPath - }), - getSettingsDirectoryPath: vi.fn().mockResolvedValue("/test/settings/path"), - getTaskDirectoryPath: vi.fn().mockResolvedValue("/test/task/path"), - } -}) - -vi.mock("@roo-code/telemetry", () => ({ - TelemetryService: { - hasInstance: vi.fn().mockReturnValue(true), - createInstance: vi.fn(), - get instance() { - return { - trackEvent: vi.fn(), - trackError: vi.fn(), - setProvider: vi.fn(), - captureModeSwitch: vi.fn(), - } - }, - }, -})) - -const VIEW_A_PROFILE = "view-a-openrouter" -const VIEW_B_PROFILE = "view-b-openrouter" -const VIEW_B_ENDPOINT = "https://router-b.example" - -const viewAProfileSettings = { - name: VIEW_A_PROFILE, - id: "view-a-id", - apiProvider: providerIdentifiers.openrouter, - openRouterApiKey: "view-a-key", - openRouterModelId: "view-a-model", -} - -const viewBProfileSettings = { - name: VIEW_B_PROFILE, - id: "view-b-id", - apiProvider: providerIdentifiers.openrouter, - openRouterApiKey: "view-b-key", - openRouterBaseUrl: VIEW_B_ENDPOINT, - openRouterModelId: "view-b-model", -} - -const profileEntries = [ - { name: VIEW_A_PROFILE, id: "view-a-id", apiProvider: providerIdentifiers.openrouter }, - { name: VIEW_B_PROFILE, id: "view-b-id", apiProvider: providerIdentifiers.openrouter }, -] - -// A history item that names neither a mode nor a profile: the restoration has no profile of its -// own to activate, so the task is built from whatever the restoring view is serving. -const HISTORY_ITEM_WITHOUT_PROFILE: HistoryItem = { - id: "endpoint-test-task", - number: 1, - ts: 1730000000000, - task: "restored task", - tokensIn: 0, - tokensOut: 0, - totalCost: 0, -} - -// A history item that names a mode: the restoration looks up that mode's saved profile and -// activates it, which re-pins the restoring view, so the task gets the mode's profile rather -// than the profile the view arrived with. -const HISTORY_ITEM_FOR_MODE: HistoryItem = { ...HISTORY_ITEM_WITHOUT_PROFILE, mode: "code" } - -/** Storage backing both views' proxies: one shared store, because the shared provider settings are - * extension-wide state and only the per-view buffers differ. */ -function makeBacking() { - const globalState: Record = { mode: "code", currentApiConfigName: "default-profile" } - const secrets: Record = {} - return { globalState, secrets } -} - -type Backing = ReturnType - -function makeContext(backing: Backing): vscode.ExtensionContext { - // Assertion: the double only needs the shape of the host context that ClineProvider and - // ContextProxy touch, which no exported type describes without the whole extension host. - return { - extensionPath: "/test/path", - extensionUri: { fsPath: "/test/path" } as vscode.Uri, - globalState: { - get: vi.fn().mockImplementation((key: string) => backing.globalState[key]), - update: vi.fn().mockImplementation((key: string, value: unknown) => { - backing.globalState[key] = value - return Promise.resolve() - }), - keys: vi.fn().mockImplementation(() => Object.keys(backing.globalState)), - }, - secrets: { - get: vi.fn().mockImplementation((key: string) => backing.secrets[key]), - store: vi.fn().mockImplementation((key: string, value: string | undefined) => { - backing.secrets[key] = value - return Promise.resolve() - }), - delete: vi.fn().mockImplementation((key: string) => { - delete backing.secrets[key] - return Promise.resolve() - }), - }, - workspaceState: { - get: vi.fn().mockReturnValue(undefined), - update: vi.fn().mockResolvedValue(undefined), - keys: vi.fn().mockReturnValue([]), - }, - subscriptions: [], - extension: { packageJSON: { version: "1.0.0" } }, - globalStorageUri: { fsPath: "/test/storage/path" }, - } as unknown as vscode.ExtensionContext -} - -function makeOutputChannel(): vscode.OutputChannel { - // Assertion: only the three methods the provider writes to are needed. - return { appendLine: vi.fn(), clear: vi.fn(), dispose: vi.fn() } as unknown as vscode.OutputChannel -} - -describe("ClineProvider - pinned profile endpoint isolation", () => { - let backing: Backing - let context: vscode.ExtensionContext - let views: ClineProvider[] - - beforeEach(() => { - vi.clearAllMocks() - taskIdCounter = 0 - if (!TelemetryService.hasInstance()) { - TelemetryService.createInstance([]) - } - backing = makeBacking() - context = makeContext(backing) - views = [] - }) - - afterEach(async () => { - const created = views - views = [] - await Promise.all(created.map((view) => view.dispose())) - }) - - async function makeView(renderContext: "sidebar" | "editor"): Promise { - const proxy = new ContextProxy(context) - // Production loads the proxy's caches during extension activation; a proxy that never - // initialized would read an empty store and could not see the shared settings at all. - await proxy.initialize() - const view = new ClineProvider(context, makeOutputChannel(), renderContext, proxy, new WebviewFocusTracker()) - await new Promise((resolve) => setTimeout(resolve, 10)) - view.getMcpHub = vi.fn().mockReturnValue({ - listTools: vi.fn().mockResolvedValue([]), - callTool: vi.fn().mockResolvedValue({ content: [] }), - listResources: vi.fn().mockResolvedValue([]), - readResource: vi.fn().mockResolvedValue({ contents: [] }), - getAllServers: vi.fn().mockReturnValue([]), - }) - vi.spyOn(view, "postStateToWebview").mockResolvedValue(undefined) - vi.spyOn(view.customModesManager, "getCustomModes").mockResolvedValue([]) - vi.spyOn(view.providerSettingsManager, "listConfig").mockResolvedValue(profileEntries) - views.push(view) - return view - } - - /** The view that commits the activation: it writes the shared store through the real - * activation path, so the pinned view only has to read what it left behind. */ - async function activatingView(): Promise { - const view = await makeView("sidebar") - vi.spyOn(view.providerSettingsManager, "getProfile").mockResolvedValue(viewBProfileSettings) - vi.spyOn(view.providerSettingsManager, "activateProfile").mockResolvedValue(viewBProfileSettings) - await view.activateProviderProfile({ name: VIEW_B_PROFILE }) - return view - } - - /** A view that pins its own profile: the persisted entry plus the profile lookup that - * loadViewState resolves it through, which is the pair a launched view restores. */ - async function pinnedView(): Promise { - const view = await makeView("editor") - vi.spyOn(view.providerSettingsManager, "getProfile").mockImplementation(async (params) => - "name" in params && params.name === VIEW_A_PROFILE ? viewAProfileSettings : viewBProfileSettings, - ) - await view["setViewStateId"]("stable-editor-view") - await view.contextProxy.setValue("viewStates", { - "stable-editor-view": { currentApiConfigName: VIEW_A_PROFILE, updatedAt: 1 }, - }) - await view["loadViewState"]() - return view - } - - /** Runs the task-creation path so that nothing after the Task constructor matters, while a - * failure that lands before the double was called still reaches the assertions. */ - async function runPastTaskConstruction(action: () => Promise): Promise { - try { - await action() - } catch (error) { - if (vi.mocked(Task).mock.calls.length === 0) { - throw error - } - } - } - - /** The configuration a task was actually constructed with, read off the Task double. */ - function configurationOfLastTask() { - const calls = vi.mocked(Task).mock.calls - const options = calls[calls.length - 1]?.[0] - if (!options) { - throw new Error("no task was constructed, so nothing was handed to Task") - } - return options.apiConfiguration - } - - it("starts a task on the pinned profile's own endpoint when another view activated one", async () => { - await activatingView() - const view = await pinnedView() - - await runPastTaskConstruction(() => view.createTask("hello", undefined, undefined, { startTask: false })) - - const apiConfiguration = configurationOfLastTask() - expect(apiConfiguration?.apiProvider).toBe(providerIdentifiers.openrouter) - expect(apiConfiguration?.openRouterApiKey).toBe("view-a-key") - expect(apiConfiguration?.openRouterModelId).toBe("view-a-model") - expect(apiConfiguration?.openRouterBaseUrl).toBeUndefined() - - const state = await view.getState() - expect(state.apiConfiguration?.openRouterBaseUrl).toBeUndefined() - expect(state.currentApiConfigName).toBe(VIEW_A_PROFILE) - - // The shared store really does carry the other view's endpoint: the assertion above is about - // this view not borrowing it, not about it never having been written. - expect((await (await makeView("sidebar")).getState()).apiConfiguration?.openRouterBaseUrl).toBe(VIEW_B_ENDPOINT) - }) - - it("restores a task that names no profile on the restoring view's own endpoint", async () => { - await activatingView() - const view = await pinnedView() - - await runPastTaskConstruction(() => - view.createTaskWithHistoryItem({ ...HISTORY_ITEM_WITHOUT_PROFILE }, { startTask: false }), - ) - - const apiConfiguration = configurationOfLastTask() - expect(apiConfiguration?.openRouterApiKey).toBe("view-a-key") - expect(apiConfiguration?.openRouterBaseUrl).toBeUndefined() - }) - - // A restored item that names a mode makes the restoration activate that mode's saved profile, - // which re-pins the restoring view. The task then gets that profile whole - never the pinned - // view's key welded onto the newly activated profile's endpoint. - it("restores a mode task on one profile's key and endpoint together", async () => { - await activatingView() - const view = await pinnedView() - - await runPastTaskConstruction(() => - view.createTaskWithHistoryItem({ ...HISTORY_ITEM_FOR_MODE }, { startTask: false }), - ) - - const apiConfiguration = configurationOfLastTask() - expect(apiConfiguration?.openRouterApiKey).toBe("view-b-key") - expect(apiConfiguration?.openRouterBaseUrl).toBe(VIEW_B_ENDPOINT) - expect((await view.getState()).currentApiConfigName).toBe(VIEW_B_PROFILE) - }) - - it("keeps the pinned profile's own fields when a partial provider edit is applied to it", async () => { - await activatingView() - const view = await pinnedView() - - await view.setValue("openRouterModelId", "edited-model") - - const overlay = view["viewLocalState"].apiConfiguration - expect(overlay?.openRouterApiKey).toBe("view-a-key") - expect(overlay?.openRouterModelId).toBe("edited-model") - expect(overlay?.openRouterBaseUrl).toBeUndefined() - - await runPastTaskConstruction(() => view.createTask("hello", undefined, undefined, { startTask: false })) - const apiConfiguration = configurationOfLastTask() - expect(apiConfiguration?.openRouterModelId).toBe("edited-model") - expect(apiConfiguration?.openRouterBaseUrl).toBeUndefined() - // The mechanism, named: the partial edit seeded from the pair this view holds rather than - // re-deriving the configuration from the shared store on the next read. - expect(view["viewApiConfigurationProfileName"]).toBe(VIEW_A_PROFILE) - }) - - // A provider change replaces the overlay wholesale, so this view stops holding a complete - // profile and reads go back to the shared store: the guard against treating a partial - // provider switch as if it were still the pinned profile's own configuration. - it("still layers a provider switch over the shared store instead of serving it alone", async () => { - await activatingView() - const view = await pinnedView() - - await view.setValues({ apiProvider: providerIdentifiers.anthropic, modelMaxTokens: 4321 }) - - const state = await view.getState() - expect(state.apiConfiguration?.apiProvider).toBe(providerIdentifiers.anthropic) - expect(state.apiConfiguration?.modelMaxTokens).toBe(4321) - expect(state.apiConfiguration?.openRouterBaseUrl).toBe(VIEW_B_ENDPOINT) - expect(view["viewApiConfigurationProfileName"]).toBeUndefined() - }) - - it("leaves a view that pins nothing reading the activated profile from the shared store", async () => { - await activatingView() - const view = await makeView("editor") - - const state = await view.getState() - expect(state.currentApiConfigName).toBe(VIEW_B_PROFILE) - expect(state.apiConfiguration?.openRouterBaseUrl).toBe(VIEW_B_ENDPOINT) - expect(state.apiConfiguration?.openRouterApiKey).toBe("view-b-key") - }) -})