feat: support passing environment variables when starting Dev Proxy

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

Author: Copilot

README.md

@@ -227,6 +227,7 @@ You can also manually add the extension to recommendations at any time using the
 | `dev-proxy-toolkit.closeTerminal` | `boolean` | `true` | Close terminal when stopping |
 | `dev-proxy-toolkit.apiPort` | `number` | `8897` | Port for Dev Proxy API communication |
 | `dev-proxy-toolkit.devProxyPath` | `string` | `""` | Custom path to Dev Proxy executable (uses auto-detection if empty) |
+| `dev-proxy-toolkit.env` | `object` | `{}` | Environment variables to set when starting Dev Proxy |
 
 ## Tasks
 
@@ -255,6 +256,22 @@ Run Dev Proxy as a VS Code task for integration with build workflows.
 }
 ```
 
+You can pass environment variables to Dev Proxy using the `env` property:
+
+```json
+{
+  "label": "Start Dev Proxy",
+  "type": "devproxy",
+  "command": "start",
+  "env": {
+    "NODE_ENV": "development",
+    "DEBUG": "true"
+  },
+  "isBackground": true,
+  "problemMatcher": "$devproxy-watch"
+}
+```
+
 ## MCP Server
 
 This extension includes an MCP server for AI-assisted development. See [Dev Proxy MCP Server](https://github.com/dev-proxy-tools/mcp) for available tools.

package.json

@@ -166,6 +166,13 @@
               "type": "string"
             },
             "description": "Additional command-line arguments"
+          },
+          "env": {
+            "type": "object",
+            "additionalProperties": {
+              "type": "string"
+            },
+            "description": "Environment variables to set when starting Dev Proxy"
           }
         }
       }
@@ -219,6 +226,14 @@
           "type": "string",
           "default": "",
           "description": "Custom path to the Dev Proxy executable. If empty, auto-detection is used."
+        },
+        "dev-proxy-toolkit.env": {
+          "type": "object",
+          "additionalProperties": {
+            "type": "string"
+          },
+          "default": {},
+          "description": "Environment variables to set when starting Dev Proxy."
         }
       }
     },

src/services/terminal.ts

@@ -10,22 +10,26 @@ export class TerminalService {
   private readonly createNewTerminal: boolean;
   private readonly showTerminal: boolean;
   private readonly closeTerminalOnStop: boolean;
+  private readonly env: { [key: string]: string } | undefined;
 
   constructor(config?: TerminalServiceConfig) {
     this.createNewTerminal = config?.createNewTerminal ?? true;
     this.showTerminal = config?.showTerminal ?? true;
     this.closeTerminalOnStop = config?.closeTerminalOnStop ?? true;
+    this.env = config?.env;
   }
 
   /**
    * Create a TerminalService using VS Code configuration.
    */
   static fromConfiguration(): TerminalService {
     const config = vscode.workspace.getConfiguration('dev-proxy-toolkit');
+    const env = config.get<{ [key: string]: string }>('env');
     return new TerminalService({
       createNewTerminal: config.get<boolean>('newTerminal', true),
       showTerminal: config.get<boolean>('showTerminal', true),
       closeTerminalOnStop: config.get<boolean>('closeTerminal', true),
+      env: env && Object.keys(env).length > 0 ? env : undefined,
     });
   }
 
@@ -41,7 +45,15 @@ export class TerminalService {
       return vscode.window.activeTerminal;
     }
 
-    const terminal = vscode.window.createTerminal('Dev Proxy');
+    const terminalOptions: vscode.TerminalOptions = {
+      name: 'Dev Proxy',
+    };
+
+    if (this.env) {
+      terminalOptions.env = this.env;
+    }
+
+    const terminal = vscode.window.createTerminal(terminalOptions);
 
     if (this.showTerminal) {
       terminal.show();
@@ -79,4 +91,5 @@ export interface TerminalServiceConfig {
   createNewTerminal?: boolean;
   showTerminal?: boolean;
   closeTerminalOnStop?: boolean;
+  env?: { [key: string]: string };
 }

src/task-provider.ts

@@ -7,6 +7,7 @@ interface DevProxyTaskDefinition extends vscode.TaskDefinition {
     command: 'start' | 'stop';
     configFile?: string;
     args?: string[];
+    env?: { [key: string]: string };
     label?: string;
 }
 
@@ -68,9 +69,13 @@ export class DevProxyTaskProvider implements vscode.TaskProvider {
 
         if (definition.command === 'start') {
             const args = this.buildArgumentsFromDefinition(definition);
-            execution = new vscode.ShellExecution(this.devProxyExe, args, {
+            const shellOptions: vscode.ShellExecutionOptions = {
                 cwd: '${workspaceFolder}'
-            });
+            };
+            if (definition.env && Object.keys(definition.env).length > 0) {
+                shellOptions.env = definition.env;
+            }
+            execution = new vscode.ShellExecution(this.devProxyExe, args, shellOptions);
         } else if (definition.command === 'stop') {
             // Use curl to stop Dev Proxy via API
             const configuration = vscode.workspace.getConfiguration('dev-proxy-toolkit');

src/test/task-provider.test.ts

@@ -161,6 +161,28 @@ suite('DevProxyTaskProvider', () => {
 
       assert.ok(resolved, 'Should resolve task with args');
     });
+
+    test('should handle env in definition', () => {
+      const provider = new DevProxyTaskProvider(mockContext);
+
+      const taskDefinition = {
+        type: 'devproxy',
+        command: 'start' as const,
+        env: { 'NODE_ENV': 'test', 'DEBUG': 'true' },
+        label: 'Start with Env',
+      };
+
+      const mockTask = new vscode.Task(
+        taskDefinition,
+        vscode.TaskScope.Workspace,
+        'Start with Env',
+        'devproxy'
+      );
+
+      const resolved = provider.resolveTask(mockTask);
+
+      assert.ok(resolved, 'Should resolve task with env');
+    });
   });
 
   suite('task properties', () => {

src/test/terminal.test.ts

@@ -111,6 +111,41 @@ suite('TerminalService', () => {
       assert.ok((mockTerminal.hide as sinon.SinonStub).calledOnce);
       assert.ok((mockTerminal.show as sinon.SinonStub).notCalled);
     });
+
+    test('should pass env to terminal when env is provided', () => {
+      const mockTerminal = {
+        show: sandbox.stub(),
+        hide: sandbox.stub(),
+        name: 'Dev Proxy',
+      } as unknown as vscode.Terminal;
+
+      const createStub = sandbox.stub(vscode.window, 'createTerminal').returns(mockTerminal);
+
+      const env = { 'NODE_ENV': 'test', 'DEBUG': 'true' };
+      const service = new TerminalService({ createNewTerminal: true, showTerminal: true, env });
+      service.getOrCreateTerminal();
+
+      assert.ok(createStub.calledOnce);
+      const options = createStub.firstCall.args[0] as vscode.TerminalOptions;
+      assert.deepStrictEqual(options.env, env, 'Should pass env to terminal options');
+    });
+
+    test('should not include env in terminal options when env is undefined', () => {
+      const mockTerminal = {
+        show: sandbox.stub(),
+        hide: sandbox.stub(),
+        name: 'Dev Proxy',
+      } as unknown as vscode.Terminal;
+
+      const createStub = sandbox.stub(vscode.window, 'createTerminal').returns(mockTerminal);
+
+      const service = new TerminalService({ createNewTerminal: true, showTerminal: true });
+      service.getOrCreateTerminal();
+
+      assert.ok(createStub.calledOnce);
+      const options = createStub.firstCall.args[0] as vscode.TerminalOptions;
+      assert.strictEqual(options.env, undefined, 'Should not include env in terminal options');
+    });
   });
 
   suite('disposeDevProxyTerminals', () => {