feat: add devProxyPath setting and improve detection. Closes #334

Author: garrytrinder

CHANGELOG.md

@@ -11,6 +11,8 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ### Added:
 
+- Setting: Added `devProxyPath` setting to specify custom path to Dev Proxy executable
+- Detection: Added auto-detection fallback using login shell and common installation paths
 - Snippets: Added `devproxy-plugin-graph-connector-guidance` - GraphConnectorGuidancePlugin instance
 - Snippets: Added `devproxy-plugin-mock-stdio-response` - MockStdioResponsePlugin instance
 - Snippets: Added `devproxy-plugin-mock-stdio-response-config` - MockStdioResponsePlugin config section

README.md

@@ -221,6 +221,7 @@ Shows Dev Proxy status at a glance:
 | `dev-proxy-toolkit.showTerminal` | `boolean` | `true` | Show terminal when starting |
 | `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) |
 
 ## Tasks
 

src/detect.ts

@@ -1,7 +1,7 @@
 import { DevProxyInstall } from './types';
 import os from 'os';
 import { VersionExeName, VersionPreference } from './enums';
-import { executeCommand } from './utils/shell';
+import { executeCommand, resolveDevProxyExecutable } from './utils/shell';
 import * as vscode from 'vscode';
 
 export const getVersion = async (devProxyExe: string) => {
@@ -16,7 +16,10 @@ export const getVersion = async (devProxyExe: string) => {
 };
 
 export const detectDevProxyInstall = async (versionPreference: VersionPreference): Promise<DevProxyInstall> => {
-    const devProxyExe = getDevProxyExe(versionPreference);
+    const configuration = vscode.workspace.getConfiguration('dev-proxy-toolkit');
+    const customPath = configuration.get<string>('devProxyPath');
+    const exeName = getDevProxyExe(versionPreference);
+    const devProxyExe = await resolveDevProxyExecutable(exeName, customPath);
     const version = await getVersion(devProxyExe);
     const isInstalled = version !== '';
     const isBeta = version.includes('beta');

src/test/shell.test.ts

@@ -3,7 +3,9 @@
  * Tests for pure utility functions in shell.ts.
  */
 import * as assert from 'assert';
-import { getPackageIdentifier } from '../utils/shell';
+import * as sinon from 'sinon';
+import * as fs from 'fs';
+import { getPackageIdentifier, resolveDevProxyExecutable } from '../utils/shell';
 import {
   PackageManager,
   VersionPreference,
@@ -40,3 +42,47 @@ suite('getPackageIdentifier', () => {
     assert.strictEqual(result, undefined);
   });
 });
+
+suite('resolveDevProxyExecutable', () => {
+  let existsSyncStub: sinon.SinonStub;
+
+  setup(() => {
+    existsSyncStub = sinon.stub(fs, 'existsSync');
+  });
+
+  teardown(() => {
+    sinon.restore();
+  });
+
+  test('should return custom path when provided and non-empty', async () => {
+    const customPath = '/custom/path/to/devproxy';
+    const result = await resolveDevProxyExecutable('devproxy', customPath);
+    assert.strictEqual(result, customPath);
+  });
+
+  test('should trim whitespace from custom path', async () => {
+    const customPath = '  /custom/path/to/devproxy  ';
+    const result = await resolveDevProxyExecutable('devproxy', customPath);
+    assert.strictEqual(result, '/custom/path/to/devproxy');
+  });
+
+  test('should ignore empty custom path and proceed with auto-detection', async () => {
+    // With empty custom path and no auto-detection success, should return bare command
+    existsSyncStub.returns(false);
+    const result = await resolveDevProxyExecutable('devproxy', '');
+    // Will fall through to bare command since nothing else succeeds
+    assert.strictEqual(result, 'devproxy');
+  });
+
+  test('should ignore whitespace-only custom path', async () => {
+    existsSyncStub.returns(false);
+    const result = await resolveDevProxyExecutable('devproxy', '   ');
+    assert.strictEqual(result, 'devproxy');
+  });
+
+  test('should handle undefined custom path', async () => {
+    existsSyncStub.returns(false);
+    const result = await resolveDevProxyExecutable('devproxy', undefined);
+    assert.strictEqual(result, 'devproxy');
+  });
+});

src/utils/index.ts

@@ -25,6 +25,7 @@ export {
   getPackageIdentifier,
   upgradeDevProxyWithPackageManager,
   openUpgradeDocumentation,
+  resolveDevProxyExecutable,
 } from './shell';
 
 // Re-export from detect for convenience

src/utils/shell.ts

@@ -1,5 +1,7 @@
 import { exec, ExecOptions } from 'child_process';
 import * as vscode from 'vscode';
+import * as os from 'os';
+import * as fs from 'fs';
 import { Urls } from '../constants';
 import {
   HomebrewPackageIdentifier,
@@ -125,3 +127,99 @@ export async function upgradeDevProxyWithPackageManager(
 export function openUpgradeDocumentation(): void {
   vscode.env.openExternal(vscode.Uri.parse(Urls.upgradeDoc));
 }
+
+/**
+ * Common installation paths for Dev Proxy on different platforms.
+ */
+const COMMON_PATHS: Record<string, string[]> = {
+  darwin: ['/opt/homebrew/bin', '/usr/local/bin'],
+  linux: ['/usr/local/bin', '/home/linuxbrew/.linuxbrew/bin'],
+  win32: [], // Windows typically has correct PATH from installer
+};
+
+/**
+ * Resolve the Dev Proxy executable path.
+ *
+ * Priority:
+ * 1. Custom path from settings (if set and non-empty)
+ * 2. Auto-detection:
+ *    a. Try bare command (devproxy/devproxy-beta)
+ *    b. Try via login shell (macOS/Linux only)
+ *    c. Try common installation paths
+ *
+ * @returns The resolved executable path, or the bare command name if not found
+ */
+export async function resolveDevProxyExecutable(
+  exeName: string,
+  customPath?: string
+): Promise<string> {
+  // 1. Use custom path if provided
+  if (customPath && customPath.trim() !== '') {
+    return customPath.trim();
+  }
+
+  // 2. Try bare command first
+  if (await canExecute(exeName)) {
+    return exeName;
+  }
+
+  const platform = os.platform();
+
+  // 3. Try via login shell (macOS/Linux only)
+  if (platform !== 'win32') {
+    const loginShellPath = await tryLoginShell(exeName);
+    if (loginShellPath) {
+      return loginShellPath;
+    }
+  }
+
+  // 4. Try common installation paths
+  const commonPaths = COMMON_PATHS[platform] || [];
+  for (const dir of commonPaths) {
+    const fullPath = `${dir}/${exeName}`;
+    if (fs.existsSync(fullPath)) {
+      return fullPath;
+    }
+  }
+
+  // Fallback to bare command (will fail gracefully in getVersion)
+  return exeName;
+}
+
+/**
+ * Check if a command can be executed successfully.
+ */
+async function canExecute(cmd: string): Promise<boolean> {
+  try {
+    await executeCommand(`${cmd} --version`);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+/**
+ * Try to find the executable using a login shell.
+ * This sources the user's shell profile which may include custom PATH entries.
+ */
+async function tryLoginShell(exeName: string): Promise<string | undefined> {
+  const shells = ['/bin/zsh', '/bin/bash'];
+
+  for (const shell of shells) {
+    if (!fs.existsSync(shell)) {
+      continue;
+    }
+
+    try {
+      const result = await executeCommand(`${shell} -l -c "which ${exeName}"`);
+      const path = result.trim();
+      if (path && !path.includes('not found')) {
+        return path;
+      }
+    } catch {
+      // Shell failed, try next
+    }
+  }
+
+  return undefined;
+}