feat: detect outdated Dev Proxy config files and offer Copilot upgrade

Add version mismatch detection for Dev Proxy config files in the workspace.
When the schema version in config files doesn't match the installed Dev Proxy
version, show a warning notification offering to upgrade using Copilot Chat.

- Add extractVersionFromSchemaUrl() to extract version from schema URLs
- Add findOutdatedConfigFiles() to scan workspace for outdated configs
- Add upgradeConfigs command that opens Copilot Chat with upgrade prompt
- Add handleOutdatedConfigFilesNotification() for the warning UI
- Add tests for version extraction and command registration

Co-authored-by: garrytrinder <11563347+garrytrinder@users.noreply.github.com>

Author: Copilot

package.json

@@ -89,6 +89,12 @@
         "title": "Generate JWT",
         "category": "Dev Proxy Toolkit",
         "enablement": "isDevProxyInstalled"
+      },
+      {
+        "command": "dev-proxy-toolkit.upgrade-configs",
+        "title": "Upgrade config files",
+        "category": "Dev Proxy Toolkit",
+        "enablement": "isDevProxyInstalled"
       }
     ],
     "mcpServerDefinitionProviders": [

src/commands/index.ts

@@ -6,6 +6,7 @@ import { registerInstallCommands } from './install';
 import { registerJwtCommands } from './jwt';
 import { registerDiscoveryCommands } from './discovery';
 import { registerDocCommands } from './docs';
+import { registerUpgradeConfigCommands } from './upgrade-config';
 
 /**
  * Register all commands for the extension.
@@ -30,6 +31,7 @@ export function registerCommands(
   registerJwtCommands(context, configuration);
   registerDiscoveryCommands(context, configuration);
   registerDocCommands(context);
+  registerUpgradeConfigCommands(context);
 }
 
 // Re-export individual modules for testing and direct access
@@ -40,3 +42,4 @@ export { registerInstallCommands } from './install';
 export { registerJwtCommands } from './jwt';
 export { registerDiscoveryCommands } from './discovery';
 export { registerDocCommands } from './docs';
+export { registerUpgradeConfigCommands } from './upgrade-config';

src/commands/upgrade-config.ts

@@ -0,0 +1,55 @@
+import * as vscode from 'vscode';
+import { Commands } from '../constants';
+import { DevProxyInstall } from '../types';
+
+/**
+ * Config upgrade commands.
+ */
+
+export function registerUpgradeConfigCommands(
+  context: vscode.ExtensionContext,
+): void {
+  context.subscriptions.push(
+    vscode.commands.registerCommand(Commands.upgradeConfigs, (fileUris?: vscode.Uri[]) =>
+      upgradeConfigsWithCopilot(context, fileUris)
+    )
+  );
+}
+
+async function upgradeConfigsWithCopilot(
+  context: vscode.ExtensionContext,
+  fileUris?: vscode.Uri[],
+): Promise<void> {
+  const devProxyInstall = context.globalState.get<DevProxyInstall>('devProxyInstall');
+  if (!devProxyInstall?.isInstalled) {
+    return;
+  }
+
+  const devProxyVersion = devProxyInstall.isBeta
+    ? devProxyInstall.version.split('-')[0]
+    : devProxyInstall.version;
+
+  const fileList = fileUris?.length
+    ? fileUris.map(uri => `- ${vscode.workspace.asRelativePath(uri)}`).join('\n')
+    : 'all Dev Proxy config files in the workspace';
+
+  const prompt = [
+    `Upgrade the following Dev Proxy configuration files to version v${devProxyVersion}:`,
+    '',
+    fileList,
+    '',
+    `Use the Dev Proxy MCP tools to get the latest schema information for v${devProxyVersion} and update each config file.`,
+    'Update the $schema URLs and make any necessary configuration changes for the new version.',
+  ].join('\n');
+
+  try {
+    await vscode.commands.executeCommand('workbench.action.chat.open', {
+      query: prompt,
+      isPartialQuery: false,
+    });
+  } catch {
+    vscode.window.showWarningMessage(
+      'Could not open Copilot Chat. Please make sure GitHub Copilot is installed and enabled.'
+    );
+  }
+}

src/constants.ts

@@ -39,6 +39,9 @@ export const Commands = {
 
   // Language model commands
   addLanguageModelConfig: 'dev-proxy-toolkit.addLanguageModelConfig',
+
+  // Config upgrade commands
+  upgradeConfigs: 'dev-proxy-toolkit.upgrade-configs',
 } as const;
 
 /**

src/extension.ts

@@ -1,6 +1,6 @@
 import * as vscode from 'vscode';
 import { registerCommands } from './commands';
-import { handleStartNotification, processNotification } from './notifications';
+import { handleStartNotification, processNotification, handleOutdatedConfigFilesNotification } from './notifications';
 import { registerDocumentListeners } from './documents';
 import { registerCodeLens } from './code-lens';
 import { createStatusBar, statusBarLoop, updateStatusBar } from './status-bar';
@@ -35,6 +35,8 @@ export const activate = async (context: vscode.ExtensionContext): Promise<vscode
   const notification = handleStartNotification(context);
   processNotification(notification);
 
+  handleOutdatedConfigFilesNotification(context);
+
   updateStatusBar(context, statusBar);
 
   // Store the interval reference for proper cleanup

src/notifications.ts

@@ -1,5 +1,7 @@
 import * as vscode from 'vscode';
 import { DevProxyInstall } from './types';
+import { Commands } from './constants';
+import { findOutdatedConfigFiles } from './utils';
 
 export const handleStartNotification = (context: vscode.ExtensionContext) => {
     const devProxyInstall = context.globalState.get<DevProxyInstall>('devProxyInstall');
@@ -50,3 +52,43 @@ export const handleStartNotification = (context: vscode.ExtensionContext) => {
 export const processNotification = (notification: (() => { message: string; show: () => Promise<void>; }) | undefined) => {
     if (notification) { notification().show(); };
 };
+
+/**
+ * Check for outdated config files and notify the user.
+ *
+ * Scans the workspace for Dev Proxy config files whose schema version
+ * doesn't match the installed Dev Proxy version and offers to upgrade
+ * them using Copilot Chat.
+ */
+export async function handleOutdatedConfigFilesNotification(
+    context: vscode.ExtensionContext,
+): Promise<void> {
+    const devProxyInstall = context.globalState.get<DevProxyInstall>('devProxyInstall');
+    if (!devProxyInstall?.isInstalled) {
+        return;
+    }
+
+    const devProxyVersion = devProxyInstall.isBeta
+        ? devProxyInstall.version.split('-')[0]
+        : devProxyInstall.version;
+
+    const outdatedFiles = await findOutdatedConfigFiles(devProxyVersion);
+
+    if (outdatedFiles.length === 0) {
+        return;
+    }
+
+    const fileCount = outdatedFiles.length;
+    const fileWord = fileCount === 1 ? 'file' : 'files';
+    const message = `${fileCount} Dev Proxy config ${fileWord} found with a schema version that doesn't match the installed version (v${devProxyVersion}).`;
+
+    const result = await vscode.window.showWarningMessage(
+        message,
+        'Upgrade with Copilot',
+        'Dismiss',
+    );
+
+    if (result === 'Upgrade with Copilot') {
+        await vscode.commands.executeCommand(Commands.upgradeConfigs, outdatedFiles);
+    }
+}

src/test/config-detection.test.ts

@@ -1,10 +1,11 @@
 /**
  * Config file detection tests.
  * Verifies isConfigFile correctly identifies Dev Proxy configuration files.
+ * Verifies extractVersionFromSchemaUrl correctly extracts versions from schema URLs.
  */
 import * as assert from 'assert';
 import * as vscode from 'vscode';
-import { isConfigFile, sleep } from '../utils';
+import { isConfigFile, extractVersionFromSchemaUrl, sleep } from '../utils';
 import { getFixturePath, testDevProxyInstall, getExtensionContext } from './helpers';
 
 suite('isConfigFile', () => {
@@ -83,3 +84,29 @@ suite('isConfigFile', () => {
     assert.strictEqual(actual, expected);
   });
 });
+
+suite('extractVersionFromSchemaUrl', () => {
+  test('should extract version from standard schema URL', () => {
+    const url = 'https://raw.githubusercontent.com/dotnet/dev-proxy/main/schemas/v0.24.0/rc.schema.json';
+    assert.strictEqual(extractVersionFromSchemaUrl(url), '0.24.0');
+  });
+
+  test('should extract version from legacy schema URL', () => {
+    const url = 'https://raw.githubusercontent.com/microsoft/dev-proxy/main/schemas/v0.14.1/rc.schema.json';
+    assert.strictEqual(extractVersionFromSchemaUrl(url), '0.14.1');
+  });
+
+  test('should extract pre-release version from schema URL', () => {
+    const url = 'https://raw.githubusercontent.com/dotnet/dev-proxy/main/schemas/v0.24.0-beta.1/rc.schema.json';
+    assert.strictEqual(extractVersionFromSchemaUrl(url), '0.24.0-beta.1');
+  });
+
+  test('should return empty string for URL without version', () => {
+    const url = 'https://example.com/schema.json';
+    assert.strictEqual(extractVersionFromSchemaUrl(url), '');
+  });
+
+  test('should return empty string for empty string', () => {
+    assert.strictEqual(extractVersionFromSchemaUrl(''), '');
+  });
+});

src/test/extension.test.ts

@@ -26,4 +26,10 @@ suite('Commands', () => {
     const jwtCreateCommand = commands.find(cmd => cmd === 'dev-proxy-toolkit.jwt-create');
     assert.ok(jwtCreateCommand, 'JWT create command should be registered');
   });
+
+  test('Upgrade configs command should be registered', async () => {
+    const commands = await vscode.commands.getCommands();
+    const upgradeConfigsCommand = commands.find(cmd => cmd === 'dev-proxy-toolkit.upgrade-configs');
+    assert.ok(upgradeConfigsCommand, 'Upgrade configs command should be registered');
+  });
 });

src/utils/config-detection.ts

@@ -1,4 +1,5 @@
 import * as vscode from 'vscode';
+import * as fs from 'fs';
 import parse from 'json-to-ast';
 
 /**
@@ -87,3 +88,65 @@ export function isProxyFile(document: vscode.TextDocument): boolean {
     return false;
   }
 }
+
+/**
+ * Extract version from a Dev Proxy schema URL.
+ *
+ * Schema URLs follow the pattern:
+ *   https://raw.githubusercontent.com/.../schemas/v{version}/{filename}
+ *
+ * @returns The version string (e.g., "0.24.0") or empty string if not found.
+ */
+export function extractVersionFromSchemaUrl(schemaUrl: string): string {
+  const match = schemaUrl.match(/\/v(\d+\.\d+\.\d+(?:-[a-zA-Z0-9.-]+)?)\//);
+  return match ? match[1] : '';
+}
+
+/**
+ * Find all Dev Proxy config files in the workspace that have an outdated schema version.
+ *
+ * Scans the workspace for JSON files containing a Dev Proxy `$schema` property
+ * and compares the schema version against the installed Dev Proxy version.
+ *
+ * @param devProxyVersion The installed Dev Proxy version (e.g., "0.24.0")
+ * @returns Array of URIs for config files with mismatched schema versions.
+ */
+export async function findOutdatedConfigFiles(devProxyVersion: string): Promise<vscode.Uri[]> {
+  const outdatedFiles: vscode.Uri[] = [];
+
+  const jsonFiles = await vscode.workspace.findFiles('**/*.{json,jsonc}', '**/node_modules/**');
+
+  for (const uri of jsonFiles) {
+    try {
+      const content = fs.readFileSync(uri.fsPath, 'utf-8');
+
+      // Quick check before parsing
+      if (!content.includes('dev-proxy') || !content.includes('schema')) {
+        continue;
+      }
+
+      const documentNode = parse(content) as parse.ObjectNode;
+      const schemaNode = getASTNode(documentNode.children, 'Identifier', '$schema');
+
+      if (!schemaNode) {
+        continue;
+      }
+
+      const schemaValue = (schemaNode.value as parse.LiteralNode).value as string;
+
+      if (!schemaValue.includes('dev-proxy') || !schemaValue.endsWith('rc.schema.json')) {
+        continue;
+      }
+
+      const schemaVersion = extractVersionFromSchemaUrl(schemaValue);
+
+      if (schemaVersion && schemaVersion !== devProxyVersion) {
+        outdatedFiles.push(uri);
+      }
+    } catch {
+      // Skip files that can't be read or parsed
+    }
+  }
+
+  return outdatedFiles;
+}

src/utils/index.ts

@@ -16,7 +16,7 @@ export {
 } from './ast';
 
 // Config file detection
-export { isConfigFile, isProxyFile } from './config-detection';
+export { isConfigFile, isProxyFile, extractVersionFromSchemaUrl, findOutdatedConfigFiles } from './config-detection';
 
 // Shell execution utilities
 export {