Cloud: support syncing provider profiles from the cloud

packages/types/src/cloud.ts

@@ -2,6 +2,7 @@ import { z } from "zod"
 
 import { globalSettingsSchema } from "./global-settings.js"
 import { mcpMarketplaceItemSchema } from "./marketplace.js"
+import { discriminatedProviderSettingsWithIdSchema } from "./provider-settings.js"
 
 /**
  * CloudUserInfo
@@ -114,6 +115,7 @@ export const organizationSettingsSchema = z.object({
 	hiddenMcps: z.array(z.string()).optional(),
 	hideMarketplaceMcps: z.boolean().optional(),
 	mcps: z.array(mcpMarketplaceItemSchema).optional(),
+	providerProfiles: z.record(z.string(), discriminatedProviderSettingsWithIdSchema).optional(),
 })
 
 export type OrganizationSettings = z.infer<typeof organizationSettingsSchema>

packages/types/src/provider-settings.ts

@@ -327,6 +327,13 @@ export const providerSettingsSchema = z.object({
 })
 
 export type ProviderSettings = z.infer<typeof providerSettingsSchema>
+
+export const providerSettingsWithIdSchema = providerSettingsSchema.extend({ id: z.string().optional() })
+export const discriminatedProviderSettingsWithIdSchema = providerSettingsSchemaDiscriminated.and(
+	z.object({ id: z.string().optional() }),
+)
+export type ProviderSettingsWithId = z.infer<typeof providerSettingsWithIdSchema>
+
 export const PROVIDER_SETTINGS_KEYS = providerSettingsSchema.keyof().options
 
 export const MODEL_ID_KEYS: Partial<keyof ProviderSettings>[] = [

src/core/config/ProviderSettingsManager.ts

@@ -1,27 +1,30 @@
 import { ExtensionContext } from "vscode"
 import { z, ZodError } from "zod"
+import deepEqual from "fast-deep-equal"
 
 import {
-	type ProviderSettingsEntry,
-	providerSettingsSchema,
-	providerSettingsSchemaDiscriminated,
+	type ProviderSettingsWithId,
+	providerSettingsWithIdSchema,
+	discriminatedProviderSettingsWithIdSchema,
+	isSecretStateKey,
+	ProviderSettingsEntry,
 	DEFAULT_CONSECUTIVE_MISTAKE_LIMIT,
 } from "@roo-code/types"
 import { TelemetryService } from "@roo-code/telemetry"
 
 import { Mode, modes } from "../../shared/modes"
 
-const providerSettingsWithIdSchema = providerSettingsSchema.extend({ id: z.string().optional() })
-const discriminatedProviderSettingsWithIdSchema = providerSettingsSchemaDiscriminated.and(
-	z.object({ id: z.string().optional() }),
-)
-
-type ProviderSettingsWithId = z.infer<typeof providerSettingsWithIdSchema>
+export interface SyncCloudProfilesResult {
+	hasChanges: boolean
+	activeProfileChanged: boolean
+	activeProfileId: string
+}
 
 export const providerProfilesSchema = z.object({
 	currentApiConfigName: z.string(),
 	apiConfigs: z.record(z.string(), providerSettingsWithIdSchema),
 	modeApiConfigs: z.record(z.string(), z.string()).optional(),
+	cloudProfileIds: z.array(z.string()).optional(),
 	migrations: z
  .object({
  rateLimitSecondsMigrated: z.boolean().optional(),
@@ -304,7 +307,7 @@ export class ProviderSettingsManager {
  const id = config.id || existingId || this.generateId()
 
  // Filter out settings from other providers.
- const filteredConfig = providerSettingsSchemaDiscriminated.parse(config)
+ const filteredConfig = discriminatedProviderSettingsWithIdSchema.parse(config)
  providerProfiles.apiConfigs[name] = { ...filteredConfig, id }
  await this.store(providerProfiles)
  return id
@@ -529,4 +532,209 @@ export class ProviderSettingsManager {
  throw new Error(`Failed to write provider profiles to secrets: ${error}`)
  }
 	}
+
+	private findUniqueProfileName(baseName: string, existingNames: Set<string>): string {
+ if (!existingNames.has(baseName)) {
+ return baseName
+ }
+
+ // Try _local first
+ const localName = `${baseName}_local`
+ if (!existingNames.has(localName)) {
+ return localName
+ }
+
+ // Try _1, _2, etc.
+ let counter = 1
+ let candidateName: string
+ do {
+ candidateName = `${baseName}_${counter}`
+ counter++
+ } while (existingNames.has(candidateName))
+
+ return candidateName
+	}
+
+	public async syncCloudProfiles(
+ cloudProfiles: Record<string, ProviderSettingsWithId>,
+ currentActiveProfileName?: string,
+	): Promise<SyncCloudProfilesResult> {
+ try {
+ return await this.lock(async () => {
+ const providerProfiles = await this.load()
+ const changedProfiles: string[] = []
+ const existingNames = new Set(Object.keys(providerProfiles.apiConfigs))
+
+ let activeProfileChanged = false
+ let activeProfileId = ""
+
+ if (currentActiveProfileName && providerProfiles.apiConfigs[currentActiveProfileName]) {
+ activeProfileId = providerProfiles.apiConfigs[currentActiveProfileName].id || ""
+ }
+
+ const currentCloudIds = new Set(providerProfiles.cloudProfileIds || [])
+ const newCloudIds = new Set(
+ Object.values(cloudProfiles)
+ .map((p) => p.id)
+ .filter((id): id is string => Boolean(id)),
+ )
+
+ // Step 1: Delete profiles that are cloud-managed but not in the new cloud profiles
+ for (const [name, profile] of Object.entries(providerProfiles.apiConfigs)) {
+ if (profile.id && currentCloudIds.has(profile.id) && !newCloudIds.has(profile.id)) {
+ // Check if we're deleting the active profile
+ if (name === currentActiveProfileName) {
+ activeProfileChanged = true
+ activeProfileId = "" // Clear the active profile ID since it's being deleted
+ }
+ delete providerProfiles.apiConfigs[name]
+ changedProfiles.push(name)
+ existingNames.delete(name)
+ }
+ }
+
+ // Step 2: Process each cloud profile
+ for (const [cloudName, cloudProfile] of Object.entries(cloudProfiles)) {
+ if (!cloudProfile.id) {
+ continue // Skip profiles without IDs
+ }
+
+ // Find existing profile with matching ID
+ const existingEntry = Object.entries(providerProfiles.apiConfigs).find(
+ ([_, profile]) => profile.id === cloudProfile.id,
+ )
+
+ if (existingEntry) {
+ // Step 3: Update existing profile
+ const [existingName, existingProfile] = existingEntry
+
+ // Check if this is the active profile
+ const isActiveProfile = existingName === currentActiveProfileName
+
+ // Merge settings, preserving secret keys
+ const updatedProfile: ProviderSettingsWithId = { ...cloudProfile }
+ for (const [key, value] of Object.entries(existingProfile)) {
+ if (isSecretStateKey(key) && value !== undefined) {
+ ;(updatedProfile as any)[key] = value
+ }
+ }
+
+ // Check if the profile actually changed using deepEqual
+ const profileChanged = !deepEqual(existingProfile, updatedProfile)
+
+ // Handle name change
+ if (existingName !== cloudName) {
+ // Remove old entry
+ delete providerProfiles.apiConfigs[existingName]
+ existingNames.delete(existingName)
+
+ // Handle name conflict
+ let finalName = cloudName
+ if (existingNames.has(cloudName)) {
+ // There's a conflict - rename the existing non-cloud profile
+ const conflictingProfile = providerProfiles.apiConfigs[cloudName]
+ if (conflictingProfile.id !== cloudProfile.id) {
+ const newName = this.findUniqueProfileName(cloudName, existingNames)
+ providerProfiles.apiConfigs[newName] = conflictingProfile
+ existingNames.add(newName)
+ changedProfiles.push(newName)
+ }
+ delete providerProfiles.apiConfigs[cloudName]
+ existingNames.delete(cloudName)
+ }
+
+ // Add updated profile with new name
+ providerProfiles.apiConfigs[finalName] = updatedProfile
+ existingNames.add(finalName)
+ changedProfiles.push(finalName)
+ if (existingName !== finalName) {
+ changedProfiles.push(existingName) // Mark old name as changed (deleted)
+ }
+
+ // If this was the active profile, mark it as changed
+ if (isActiveProfile) {
+ activeProfileChanged = true
+ activeProfileId = cloudProfile.id || ""
+ }
+ } else if (profileChanged) {
+ // Same name, but profile content changed - update in place
+ providerProfiles.apiConfigs[existingName] = updatedProfile
+ changedProfiles.push(existingName)
+
+ // If this was the active profile and settings changed, mark it as changed
+ if (isActiveProfile) {
+ activeProfileChanged = true
+ activeProfileId = cloudProfile.id || ""
+ }
+ }
+ // If name is the same and profile hasn't changed, do nothing
+ } else {
+ // Step 4: Add new cloud profile
+ let finalName = cloudName
+
+ // Handle name conflict with existing non-cloud profile
+ if (existingNames.has(cloudName)) {
+ const existingProfile = providerProfiles.apiConfigs[cloudName]
+ if (existingProfile.id !== cloudProfile.id) {
+ // Rename the existing profile
+ const newName = this.findUniqueProfileName(cloudName, existingNames)
+ providerProfiles.apiConfigs[newName] = existingProfile
+ existingNames.add(newName)
+ changedProfiles.push(newName)
+
+ // Remove the old entry
+ delete providerProfiles.apiConfigs[cloudName]
+ existingNames.delete(cloudName)
+ }
+ }
+
+ // Add the new cloud profile (without secret keys)
+ const newProfile: ProviderSettingsWithId = { ...cloudProfile }
+ // Remove any secret keys from cloud profile
+ for (const key of Object.keys(newProfile)) {
+ if (isSecretStateKey(key)) {
+ delete (newProfile as any)[key]
+ }
+ }
+
+ providerProfiles.apiConfigs[finalName] = newProfile
+ existingNames.add(finalName)
+ changedProfiles.push(finalName)
+ }
+ }
+
+ // Step 5: Handle case where all profiles might be deleted
+ if (Object.keys(providerProfiles.apiConfigs).length === 0 && changedProfiles.length > 0) {
+ // Create a default profile only if we have changed profiles
+ const defaultProfile = { id: this.generateId() }
+ providerProfiles.apiConfigs["default"] = defaultProfile
+ activeProfileChanged = true
+ activeProfileId = defaultProfile.id || ""
+ changedProfiles.push("default")
+ }
+
+ // Step 6: If active profile was deleted, find a replacement
+ if (activeProfileChanged && !activeProfileId) {
+ const firstProfile = Object.values(providerProfiles.apiConfigs)[0]
+ if (firstProfile?.id) {
+ activeProfileId = firstProfile.id
+ }
+ }
+
+ // Step 7: Update cloudProfileIds
+ providerProfiles.cloudProfileIds = Array.from(newCloudIds)
+
+ // Save the updated profiles
+ await this.store(providerProfiles)
+
+ return {
+ hasChanges: changedProfiles.length > 0,
+ activeProfileChanged,
+ activeProfileId,
+ }
+ })
+ } catch (error) {
+ throw new Error(`Failed to sync cloud profiles: ${error}`)
+ }
+	}
 }