fix: read workspaceSearchPaths scoped per folder in multi-root workspaces (#1448)

In a multi-root workspace, `python-envs.workspaceSearchPaths` set in a
folder's `.vscode/settings.json` was silently ignored.
`getWorkspaceSearchPaths()` called `getConfiguration('python-envs')`
without a scope URI, so `inspect().workspaceFolderValue` was always
`undefined` — VS Code needs a folder URI to resolve per-folder settings.

## Changes

- **`getWorkspaceSearchPaths(scope?: Uri)`** — accepts an optional
folder URI and passes it to `getConfiguration`, allowing VS Code to
return the correct `workspaceFolderValue` per folder.

- **`getAllExtraSearchPaths()`** — replaced the single unscoped call
with a per-folder loop. Each workspace folder's paths are resolved
relative to *that specific folder*, not broadcast against all folders.

```typescript
// Before — one unscoped call; workspaceFolderValue always undefined in multi-root
const workspaceSearchPaths = getWorkspaceSearchPaths();
// relative paths then resolved against every workspace folder

// After — one call per folder, scope-aware
for (const folder of workspaceFolders) {
    const paths = getWorkspaceSearchPaths(folder.uri);   // scoped ✓
    workspaceSearchPathsPerFolder.push({ paths, folder: folder.uri });
}
// each relative path resolved only against the folder it came from
```

- **New unit tests** — two multi-root scenarios: (1) verifies
folder-specific configs are read independently via scoped calls, (2)
verifies a relative path from `folderA` is not resolved against
`folderB`.

> [!WARNING]
>
> <details>
> <summary>Firewall rules blocked me from connecting to one or more
addresses (expand for details)</summary>
>
> #### I tried to connect to the following addresses, but was blocked by
firewall rules:
>
> - `https://api.github.com/graphql`
> - Triggering command: `/usr/bin/gh gh issue list --state open --limit
5 --json number,title,labels` (http block)
>
> If you need me to access, download, or install something from one of
these locations, you can either:
>
> - Configure [Actions setup
steps](https://gh.io/copilot/actions-setup-steps) to set up my
environment, which run before the firewall is enabled
> - Add the appropriate URLs or hosts to the custom allowlist in this
repository's [Copilot coding agent
settings](https://github.com/microsoft/vscode-python-environments/settings/copilot/coding_agent)
(admins only)
>
> </details>

<!-- START COPILOT ORIGINAL PROMPT -->



<details>

<summary>Original prompt</summary>


## Problem

In a multi-root workspace, `python-envs.workspaceSearchPaths` configured
in a folder's `.vscode/settings.json` is silently ignored. This is
because `getWorkspaceSearchPaths()` in
`src/managers/common/nativePythonFinder.ts` calls
`getConfiguration('python-envs')` **without passing a scope URI**. In VS
Code's API, when no scope is provided, `inspect().workspaceFolderValue`
is `undefined` in multi-root workspaces — VS Code doesn't know which
folder to inspect.

Fixes
#1417

## Root Cause

In `src/managers/common/nativePythonFinder.ts`:

1. **`getWorkspaceSearchPaths()`** (around line 900) calls
`getConfiguration('python-envs')` without a scope parameter. In a
multi-root workspace,
`inspect('workspaceSearchPaths').workspaceFolderValue` is always
`undefined` because VS Code needs a folder URI to know which folder's
settings to return.

2. **`getAllExtraSearchPaths()`** (around line 824) calls
`getWorkspaceSearchPaths()` only once (unscoped), then resolves relative
paths against *all* workspace folders. This is incorrect for multi-root:
if folderA configures `./envs` and folderB configures `./venvs`, you
don't want `./envs` resolved against folderB.

## Required Fix

### 1. `getWorkspaceSearchPaths()` — add an optional `scope` parameter

Change the function signature to accept an optional `Uri` scope and pass
it to `getConfiguration`:

```typescript
function getWorkspaceSearchPaths(scope?: Uri): string[] {
    try {
        const envConfig = getConfiguration('python-envs', scope);  // ← pass scope
        const inspection = envConfig.inspect<string[]>('workspaceSearchPaths');
        // ... rest of function stays the same
```

### 2. `getAllExtraSearchPaths()` — iterate over workspace folders

Replace the current single unscoped call with a per-folder loop. Instead
of:
```typescript
const workspaceSearchPaths = getWorkspaceSearchPaths();
```

Do:
```typescript
const workspaceFolders = getWorkspaceFolders();
const workspaceSearchPathsPerFolder: { paths: string[]; folder?: Uri }[] = [];

if (workspaceFolders && workspaceFolders.length > 0) {
    for (const folder of workspaceFolders) {
        const paths = getWorkspaceSearchPaths(folder.uri);
        workspaceSearchPathsPerFolder.push({ paths, folder: folder.uri });
    }
} else {
    // No workspace folders — fall back to unscoped
    workspaceSearchPathsPerFolder.push({ paths: getWorkspaceSearchPaths() });
}

// Resolve relative paths against the *specific* folder they came from
for (const { paths, folder } of workspaceSearchPathsPerFolder) {
    for (const searchPath of paths) {
        if (!searchPath || searchPath.trim() === '') continue;
        const trimmedPath = searchPath.trim();

        if (isAbsolutePath(trimmedPath)) {
            searchDirectories.push(trimmedPath);
        } else if (folder) {
            const resolvedPath = path.resolve(folder.fsPath, trimmedPath);
            searchDirectories.push(resolvedPath);
        } else {
            traceWarn('No workspace folder for relative search path:', trimmedPath);
        }
    }
}
```

### 3. Update the existing unit tests

The existing tests in
`src/test/managers/common/nativePythonFinder.getAllExtraSearchPaths.unit.test.ts`
mock `getConfiguration` without a scope. The tests that exercise
`workspaceFolderValue` will need to be updated so that the mock returns
the correct `workspaceFolderValue` when called with a specific folder
URI scope. Make sure all existing tests still pass, and add a new test
that verifies multi-root folder-level settings are read correctly (i.e.,
different folders returning different `workspaceSearchPaths`).


The following is the prior conversation context from the user's chat
exploration (may be truncated):

User: Tell me how to repro and debug this.

Assistant: 

Let me investigate the issue and the codebase to understand how
`python-envs.workspaceSearchPaths` is handled and why it might be
silently ignored in multi-root workspaces.

Assistant: Now I have a thorough understanding of the code. Here's the
root cause and how to repro/debug:

---

## Root Cause

The bug is in `getWorkspaceSearchPaths()` at [`nativePythonFinder.ts`
lines
900–927](https://github.com/microsoft/vscode-python-environments/blob/d9e20315f1947bae6dc1b753a11e7fc21255970a/src/managers/common/nativePythonFinder.ts#L900-L927).
The function calls `getConfiguration('python-envs')` **without passing a
scope** (i.e., no workspace-folder `Uri`):

```typescript name=src/managers/common/nativePythonFinder.ts url=https://github.com/microsoft/vscode-python-environments/blob/d9e20315f1947bae6dc1b753a11e7fc21255970a/src/managers/common/nativePythonFinder.ts#L900-L927
function getWorkspaceSearchPaths(): string[] {
    try {
        const envConfig = getConfiguration('python-envs');  // ← no scope!
        const inspection = envConfig.inspect<string[]>('workspaceSearchPaths');
        // ...
        if (inspection?.workspaceFolderValue) ...

</details>



<!-- START COPILOT CODING AGENT SUFFIX -->

*This pull request was created from Copilot chat.*
>

---------

Co-authored-by: copilot-swe-agent[bot] <198982749+Copilot@users.noreply.github.com>
Co-authored-by: edvilme <5952839+edvilme@users.noreply.github.com>
Co-authored-by: Eduardo Villalpando Mello <eduardo.villalpando.mello@gmail.com>

Author: Copilot

src/managers/common/nativePythonFinder.ts

@@ -1233,30 +1233,38 @@ export async function getAllExtraSearchPaths(): Promise<string[]> {
     const globalSearchPaths = getGlobalSearchPaths().filter((path) => path && path.trim() !== '');
     searchDirectories.push(...globalSearchPaths);
 
-    // Get workspaceSearchPaths
-    const workspaceSearchPaths = getWorkspaceSearchPaths();
-
-    // Resolve relative paths against workspace folders
-    for (const searchPath of workspaceSearchPaths) {
-        if (!searchPath || searchPath.trim() === '') {
-            continue;
+    // Get workspaceSearchPaths — scoped per workspace folder in multi-root workspaces
+    const workspaceFolders = getWorkspaceFolders();
+    const workspaceSearchPathsPerFolder: { paths: string[]; folder?: Uri }[] = [];
+
+    if (workspaceFolders && workspaceFolders.length > 0) {
+        for (const folder of workspaceFolders) {
+            const paths = getWorkspaceSearchPaths(folder.uri);
+            workspaceSearchPathsPerFolder.push({ paths, folder: folder.uri });
         }
+    } else {
+        // No workspace folders — fall back to unscoped call
+        workspaceSearchPathsPerFolder.push({ paths: getWorkspaceSearchPaths() });
+    }
+
+    // Resolve relative paths against the specific folder they came from
+    for (const { paths, folder } of workspaceSearchPathsPerFolder) {
+        for (const searchPath of paths) {
+            if (!searchPath || searchPath.trim() === '') {
+                continue;
+            }
 
-        const trimmedPath = searchPath.trim();
+            const trimmedPath = searchPath.trim();
 
-        if (isAbsolutePath(trimmedPath)) {
-            // Absolute path - use as is
-            searchDirectories.push(trimmedPath);
-        } else {
-            // Relative path - resolve against all workspace folders
-            const workspaceFolders = getWorkspaceFolders();
-            if (workspaceFolders) {
-                for (const workspaceFolder of workspaceFolders) {
-                    const resolvedPath = path.resolve(workspaceFolder.uri.fsPath, trimmedPath);
-                    searchDirectories.push(resolvedPath);
-                }
+            if (isAbsolutePath(trimmedPath)) {
+                // Absolute path - use as is
+                searchDirectories.push(trimmedPath);
+            } else if (folder) {
+                // Relative path - resolve against the specific folder it came from
+                const resolvedPath = path.resolve(folder.fsPath, trimmedPath);
+                searchDirectories.push(resolvedPath);
             } else {
-                traceWarn('No workspace folders found for relative search path:', trimmedPath);
+                traceWarn('No workspace folder for relative search path:', trimmedPath);
             }
         }
     }
@@ -1298,9 +1306,9 @@ export function resetWorkspaceSearchPathsGlobalWarningFlag(): void {
  * Gets the most specific workspace-level setting available for workspaceSearchPaths.
  * Supports glob patterns which are expanded by PET.
  */
-function getWorkspaceSearchPaths(): string[] {
+function getWorkspaceSearchPaths(scope?: Uri): string[] {
     try {
-        const envConfig = getConfiguration('python-envs');
+        const envConfig = getConfiguration('python-envs', scope);
         const inspection = envConfig.inspect<string[]>('workspaceSearchPaths');
 
         if (inspection?.globalValue && !workspaceSearchPathsGlobalWarningShown) {

src/test/managers/common/nativePythonFinder.getAllExtraSearchPaths.unit.test.ts

@@ -1,4 +1,5 @@
 import assert from 'node:assert';
+import * as path from 'node:path';
 import * as sinon from 'sinon';
 import { Uri } from 'vscode';
 import * as logging from '../../../common/logging';
@@ -480,6 +481,133 @@ suite('getAllExtraSearchPaths Integration Tests', () => {
             assert.ok(mockTraceWarn.called, 'Should warn about missing workspace folders');
         });
 
+        test('Multi-root workspace - each folder reads its own workspaceSearchPaths', async () => {
+            // Mock → Two folders with different folder-level workspaceSearchPaths
+            const workspace1 = Uri.file('/workspace/project1');
+            const workspace2 = Uri.file('/workspace/project2');
+
+            // Create separate config objects for each folder
+            const envConfig1: MockWorkspaceConfig = {
+                get: sinon.stub(),
+                inspect: sinon.stub(),
+                update: sinon.stub(),
+            };
+            const envConfig2: MockWorkspaceConfig = {
+                get: sinon.stub(),
+                inspect: sinon.stub(),
+                update: sinon.stub(),
+            };
+
+            envConfig1.inspect.withArgs('globalSearchPaths').returns({ globalValue: [] });
+            envConfig1.inspect.withArgs('workspaceSearchPaths').returns({
+                workspaceFolderValue: ['/envs/project1'],
+            });
+
+            envConfig2.inspect.withArgs('globalSearchPaths').returns({ globalValue: [] });
+            envConfig2.inspect.withArgs('workspaceSearchPaths').returns({
+                workspaceFolderValue: ['/envs/project2'],
+            });
+
+            // Return folder-specific configs based on the scope URI passed to getConfiguration
+            mockGetConfiguration.callsFake((section: string, scope?: unknown) => {
+                if (section === 'python') {
+                    return pythonConfig;
+                }
+                if (section === 'python-envs') {
+                    if (scope && (scope as Uri).fsPath === workspace1.fsPath) {
+                        return envConfig1;
+                    }
+                    if (scope && (scope as Uri).fsPath === workspace2.fsPath) {
+                        return envConfig2;
+                    }
+                    return envConfig; // fallback for unscoped calls
+                }
+                throw new Error(`Unexpected configuration section: ${section}`);
+            });
+
+            pythonConfig.get.withArgs('venvPath').returns(undefined);
+            pythonConfig.get.withArgs('venvFolders').returns(undefined);
+            mockGetWorkspaceFolders.returns([{ uri: workspace1 }, { uri: workspace2 }]);
+
+            // Run
+            const result = await getAllExtraSearchPaths();
+
+            // Assert - each folder's workspaceSearchPaths is read independently
+            assert.ok(result.includes('/envs/project1'), 'Should include project1 env path');
+            assert.ok(result.includes('/envs/project2'), 'Should include project2 env path');
+            assert.strictEqual(result.length, 2, 'Should have exactly 2 paths (one per folder)');
+        });
+
+        test('Multi-root workspace - relative paths resolved against the correct folder', async () => {
+            // Mock → Two folders, each with a relative workspaceSearchPaths
+            const workspace1 = Uri.file('/workspace/project1');
+            const workspace2 = Uri.file('/workspace/project2');
+
+            const envConfig1: MockWorkspaceConfig = {
+                get: sinon.stub(),
+                inspect: sinon.stub(),
+                update: sinon.stub(),
+            };
+            const envConfig2: MockWorkspaceConfig = {
+                get: sinon.stub(),
+                inspect: sinon.stub(),
+                update: sinon.stub(),
+            };
+
+            envConfig1.inspect.withArgs('globalSearchPaths').returns({ globalValue: [] });
+            envConfig1.inspect.withArgs('workspaceSearchPaths').returns({
+                workspaceFolderValue: ['envs'],
+            });
+
+            envConfig2.inspect.withArgs('globalSearchPaths').returns({ globalValue: [] });
+            envConfig2.inspect.withArgs('workspaceSearchPaths').returns({
+                workspaceFolderValue: ['venvs'],
+            });
+
+            mockGetConfiguration.callsFake((section: string, scope?: unknown) => {
+                if (section === 'python') {
+                    return pythonConfig;
+                }
+                if (section === 'python-envs') {
+                    if (scope && (scope as Uri).fsPath === workspace1.fsPath) {
+                        return envConfig1;
+                    }
+                    if (scope && (scope as Uri).fsPath === workspace2.fsPath) {
+                        return envConfig2;
+                    }
+                    return envConfig;
+                }
+                throw new Error(`Unexpected configuration section: ${section}`);
+            });
+
+            pythonConfig.get.withArgs('venvPath').returns(undefined);
+            pythonConfig.get.withArgs('venvFolders').returns(undefined);
+            mockGetWorkspaceFolders.returns([{ uri: workspace1 }, { uri: workspace2 }]);
+
+            // Run
+            const result = await getAllExtraSearchPaths();
+
+            // Assert - relative paths resolved only against their own folder
+            // .replace(/\\/g, '/') mirrors the normalization getAllExtraSearchPaths() applies to all
+            // returned paths, so results always use forward slashes regardless of platform.
+            const expected1 = path.resolve(workspace1.fsPath, 'envs').replace(/\\/g, '/');
+            const expected2 = path.resolve(workspace2.fsPath, 'venvs').replace(/\\/g, '/');
+            const wrong1In2 = path.resolve(workspace2.fsPath, 'envs').replace(/\\/g, '/');
+            const wrong2In1 = path.resolve(workspace1.fsPath, 'venvs').replace(/\\/g, '/');
+
+            assert.strictEqual(result.length, 2, 'Should have exactly 2 paths (one per folder)');
+            assert.ok(result.includes(expected1), 'project1/envs should come from project1 config');
+            assert.ok(result.includes(expected2), 'project2/venvs should come from project2 config');
+            assert.ok(
+                !result.includes(wrong1In2),
+                'project1 relative path should not be resolved against project2',
+            );
+            assert.ok(
+                !result.includes(wrong2In1),
+                'project2 relative path should not be resolved against project1',
+            );
+        });
+
         test('Empty and whitespace paths are skipped', async () => {
             // Mock → Mix of valid and invalid paths
             pythonConfig.get.withArgs('venvPath').returns(undefined);