Add Start with Options interactive command for Dev Proxy

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

Author: Copilot

CHANGELOG.md

@@ -11,6 +11,7 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ### Added:
 
+- Command: Added `Start with Options...` to launch Dev Proxy with interactive prompts for CLI settings
 - Install: Added automated install and upgrade support for Linux using official setup scripts
 - Quick Fixes: Enable local language model fix now adds or updates `languageModel.enabled: true` for supported plugins only
 - Workspace: Added automatic prompt to recommend extension in `.vscode/extensions.json` when Dev Proxy config files are detected

README.md

@@ -25,6 +25,7 @@ Control Dev Proxy directly from VS Code via the Command Palette (`Cmd+Shift+P` /
 | Command | When Available |
 |---------|----------------|
 | Start | Dev Proxy not running |
+| Start with Options... | Dev Proxy not running |
 | Stop | Dev Proxy running |
 | Restart | Dev Proxy running |
 | Raise mock request | Dev Proxy running |

package.json

@@ -28,6 +28,13 @@
         "icon": "$(debug-start)",
         "enablement": "!isDevProxyRunning"
       },
+      {
+        "command": "dev-proxy-toolkit.start-with-options",
+        "title": "Start with Options...",
+        "category": "Dev Proxy Toolkit",
+        "icon": "$(debug-alt)",
+        "enablement": "!isDevProxyRunning"
+      },
       {
         "command": "dev-proxy-toolkit.stop",
         "title": "Stop",
@@ -114,6 +121,11 @@
           "group": "navigation@1",
           "when": "!activeEditorIsDirty && isDevProxyConfigFile && !isDevProxyRunning"
         },
+        {
+          "command": "dev-proxy-toolkit.start-with-options",
+          "group": "navigation@1",
+          "when": "!activeEditorIsDirty && isDevProxyConfigFile && !isDevProxyRunning"
+        },
         {
           "command": "dev-proxy-toolkit.stop",
           "group": "navigation@2",

src/commands/proxy.ts

@@ -7,7 +7,7 @@ import { getDevProxyExe } from '../detect';
 import { VersionPreference } from '../enums';
 
 /**
- * Proxy lifecycle commands: start, stop, restart.
+ * Proxy lifecycle commands: start, start with options, stop, restart.
  *
  * These commands control the Dev Proxy process.
  */
@@ -24,6 +24,12 @@ export function registerProxyCommands(
     vscode.commands.registerCommand(Commands.start, () => startDevProxy(configuration, devProxyExe))
   );
 
+  context.subscriptions.push(
+    vscode.commands.registerCommand(Commands.startWithOptions, () =>
+      startDevProxyWithOptions(devProxyExe)
+    )
+  );
+
   context.subscriptions.push(
     vscode.commands.registerCommand(Commands.stop, () =>
       stopDevProxy(apiClient, devProxyExe, configuration)
@@ -50,6 +56,306 @@ async function startDevProxy(
   terminalService.sendCommand(terminal, command);
 }
 
+async function startDevProxyWithOptions(devProxyExe: string): Promise<void> {
+  const args: string[] = [];
+
+  // Config file
+  const configFiles = await vscode.workspace.findFiles(
+    '**/devproxyrc.{json,jsonc}',
+    '**/node_modules/**'
+  );
+  const configItems: vscode.QuickPickItem[] = [
+    { label: '$(remove) None', description: 'Use default configuration' },
+    ...configFiles.map(f => ({
+      label: vscode.workspace.asRelativePath(f),
+      description: f.fsPath,
+    })),
+  ];
+
+  const selectedConfig = await vscode.window.showQuickPick(configItems, {
+    title: 'Start with Options (1/13): Config file',
+    placeHolder: 'Select a config file',
+  });
+  if (selectedConfig === undefined) {
+    return;
+  }
+  if (selectedConfig.description && selectedConfig.description !== 'Use default configuration') {
+    args.push('--config-file', `"${selectedConfig.description}"`);
+  }
+
+  // Port
+  const port = await vscode.window.showInputBox({
+    title: 'Start with Options (2/13): Port',
+    prompt: 'Enter the proxy port number',
+    value: '8000',
+    validateInput: validatePortNumber,
+  });
+  if (port === undefined) {
+    return;
+  }
+  if (port && port !== '8000') {
+    args.push('--port', port);
+  }
+
+  // API port
+  const apiPort = await vscode.window.showInputBox({
+    title: 'Start with Options (3/13): API port',
+    prompt: 'Enter the API port number',
+    value: '8897',
+    validateInput: validatePortNumber,
+  });
+  if (apiPort === undefined) {
+    return;
+  }
+  if (apiPort && apiPort !== '8897') {
+    args.push('--api-port', apiPort);
+  }
+
+  // IP address
+  const ipAddress = await vscode.window.showInputBox({
+    title: 'Start with Options (4/13): IP address',
+    prompt: 'Enter the IP address to listen on',
+    value: '127.0.0.1',
+    validateInput: validateIpAddress,
+  });
+  if (ipAddress === undefined) {
+    return;
+  }
+  if (ipAddress && ipAddress !== '127.0.0.1') {
+    args.push('--ip-address', ipAddress);
+  }
+
+  // As system proxy
+  const asSystemProxy = await vscode.window.showQuickPick(
+    [
+      { label: 'Yes', description: 'Register as system proxy (default)' },
+      { label: 'No', description: 'Do not register as system proxy' },
+    ],
+    {
+      title: 'Start with Options (5/13): As system proxy',
+      placeHolder: 'Register Dev Proxy as a system proxy?',
+    }
+  );
+  if (asSystemProxy === undefined) {
+    return;
+  }
+  if (asSystemProxy.label === 'No') {
+    args.push('--as-system-proxy', 'false');
+  }
+
+  // Install cert
+  const installCert = await vscode.window.showQuickPick(
+    [
+      { label: 'Yes', description: 'Install certificate (default)' },
+      { label: 'No', description: 'Do not install certificate' },
+    ],
+    {
+      title: 'Start with Options (6/13): Install certificate',
+      placeHolder: 'Install the root certificate?',
+    }
+  );
+  if (installCert === undefined) {
+    return;
+  }
+  if (installCert.label === 'No') {
+    args.push('--install-cert', 'false');
+  }
+
+  // Log level
+  const logLevel = await vscode.window.showQuickPick(
+    ['trace', 'debug', 'information', 'warning', 'error'],
+    {
+      title: 'Start with Options (7/13): Log level',
+      placeHolder: 'Select a log level',
+    }
+  );
+  if (logLevel === undefined) {
+    return;
+  }
+  if (logLevel !== 'information') {
+    args.push('--log-level', logLevel);
+  }
+
+  // Failure rate
+  const failureRate = await vscode.window.showInputBox({
+    title: 'Start with Options (8/13): Failure rate',
+    prompt: 'Enter the failure rate (0-100)',
+    value: '50',
+    validateInput: validateFailureRate,
+  });
+  if (failureRate === undefined) {
+    return;
+  }
+  if (failureRate && failureRate !== '50') {
+    args.push('--failure-rate', failureRate);
+  }
+
+  // URLs to watch
+  const urlsToWatch = await vscode.window.showInputBox({
+    title: 'Start with Options (9/13): URLs to watch',
+    prompt: 'Enter URLs to watch (space separated). Leave empty to use config file values.',
+    placeHolder: 'https://api.example.com/* https://graph.microsoft.com/v1.0/*',
+    value: '',
+  });
+  if (urlsToWatch === undefined) {
+    return;
+  }
+  if (urlsToWatch.trim()) {
+    args.push('--urls-to-watch', urlsToWatch.trim());
+  }
+
+  // Record
+  const record = await vscode.window.showQuickPick(
+    [
+      { label: 'No', description: 'Do not record (default)' },
+      { label: 'Yes', description: 'Start recording immediately' },
+    ],
+    {
+      title: 'Start with Options (10/13): Record',
+      placeHolder: 'Start recording on launch?',
+    }
+  );
+  if (record === undefined) {
+    return;
+  }
+  if (record.label === 'Yes') {
+    args.push('--record');
+  }
+
+  // No first run
+  const noFirstRun = await vscode.window.showQuickPick(
+    [
+      { label: 'No', description: 'Show first run experience (default)' },
+      { label: 'Yes', description: 'Skip first run experience' },
+    ],
+    {
+      title: 'Start with Options (11/13): No first run',
+      placeHolder: 'Skip the first run experience?',
+    }
+  );
+  if (noFirstRun === undefined) {
+    return;
+  }
+  if (noFirstRun.label === 'Yes') {
+    args.push('--no-first-run');
+  }
+
+  // Timeout
+  const timeout = await vscode.window.showInputBox({
+    title: 'Start with Options (12/13): Timeout',
+    prompt: 'Enter timeout in seconds. Leave empty for no timeout.',
+    value: '',
+    validateInput: validateTimeout,
+  });
+  if (timeout === undefined) {
+    return;
+  }
+  if (timeout.trim()) {
+    args.push('--timeout', timeout.trim());
+  }
+
+  // Watch PIDs
+  const watchPids = await vscode.window.showInputBox({
+    title: 'Start with Options (13/13): Watch PIDs and process names',
+    prompt: 'Enter process IDs to watch (space separated). Leave empty to skip.',
+    placeHolder: '1234 5678',
+    value: '',
+    validateInput: validateWatchPids,
+  });
+  if (watchPids === undefined) {
+    return;
+  }
+  if (watchPids.trim()) {
+    args.push('--watch-pids', watchPids.trim());
+  }
+
+  // Watch process names
+  const watchProcessNames = await vscode.window.showInputBox({
+    prompt: 'Enter process names to watch (space separated). Leave empty to skip.',
+    placeHolder: 'msedge chrome',
+    value: '',
+    validateInput: validateProcessNames,
+  });
+  if (watchProcessNames === undefined) {
+    return;
+  }
+  if (watchProcessNames.trim()) {
+    args.push('--watch-process-names', watchProcessNames.trim());
+  }
+
+  const command = [devProxyExe, ...args].join(' ');
+  const terminalService = TerminalService.fromConfiguration();
+  const terminal = terminalService.getOrCreateTerminal();
+  terminalService.sendCommand(terminal, command);
+}
+
+function validatePortNumber(value: string): string | undefined {
+  if (!value) {
+    return undefined;
+  }
+  const num = Number(value);
+  if (!Number.isInteger(num) || num < 1 || num > 65535) {
+    return 'Port must be an integer between 1 and 65535';
+  }
+  return undefined;
+}
+
+function validateIpAddress(value: string): string | undefined {
+  if (!value) {
+    return undefined;
+  }
+  if (!/^\d{1,3}\.\d{1,3}\.\d{1,3}\.\d{1,3}$/.test(value)) {
+    return 'Enter a valid IPv4 address (e.g. 127.0.0.1)';
+  }
+  return undefined;
+}
+
+function validateFailureRate(value: string): string | undefined {
+  if (!value) {
+    return undefined;
+  }
+  const num = Number(value);
+  if (!Number.isInteger(num) || num < 0 || num > 100) {
+    return 'Failure rate must be an integer between 0 and 100';
+  }
+  return undefined;
+}
+
+function validateTimeout(value: string): string | undefined {
+  if (!value) {
+    return undefined;
+  }
+  const num = Number(value);
+  if (!Number.isInteger(num) || num < 1) {
+    return 'Timeout must be a positive integer';
+  }
+  return undefined;
+}
+
+function validateWatchPids(value: string): string | undefined {
+  if (!value) {
+    return undefined;
+  }
+  const parts = value.trim().split(/\s+/);
+  for (const part of parts) {
+    const num = Number(part);
+    if (!Number.isInteger(num) || num < 1) {
+      return 'PIDs must be positive integers separated by spaces';
+    }
+  }
+  return undefined;
+}
+
+function validateProcessNames(value: string): string | undefined {
+  if (!value) {
+    return undefined;
+  }
+  if (!/^[a-zA-Z0-9\s]+$/.test(value)) {
+    return 'Process names can only contain alphanumeric characters and spaces';
+  }
+  return undefined;
+}
+
 async function stopDevProxy(
   apiClient: DevProxyApiClient,
   devProxyExe: string,

src/constants.ts

@@ -10,6 +10,7 @@
 export const Commands = {
   // Proxy lifecycle commands
   start: 'dev-proxy-toolkit.start',
+  startWithOptions: 'dev-proxy-toolkit.start-with-options',
   stop: 'dev-proxy-toolkit.stop',
   restart: 'dev-proxy-toolkit.restart',
 

src/test/commands.test.ts

@@ -21,6 +21,13 @@ suite('Command Registration', () => {
     );
   });
 
+  test('start-with-options command should be registered', () => {
+    assert.ok(
+      registeredCommands.includes(Commands.startWithOptions),
+      `Command ${Commands.startWithOptions} should be registered`
+    );
+  });
+
   test('stop command should be registered', () => {
     assert.ok(
       registeredCommands.includes(Commands.stop),