fix: skip terminal activation when there is no activate script (#1801)

Fixes #1775

## Problem

When an interpreter's `bin/` has no `activate` script,
`getShellActivationCommands(binDir)` still emitted `source
<bin>/activate` for sh, bash, zsh, Git Bash, ksh and the `unknown`
fallback. `uv python install` toolchains are an example: they're base
interpreters, not virtual environments. Every new terminal then ran a
failing command:

```
source: no such file or directory: ~/.local/share/uv/python/cpython-3.13.9-macos-aarch64-none/bin/activate
```

The other shells (csh, fish, xonsh, nu, pwsh, cmd) were already gated on
their script existing.

## Fix

- `getShellActivationCommands` only adds the `activate`-based entries
(`unknown`, sh, bash, Git Bash, zsh, ksh) when `<binDir>/activate`
exists. This matches how the other shells are handled. Real venvs,
pipenv and poetry environments always ship `activate`, so they're
unaffected.
- `isActivatableEnvironment` now requires a non-empty `shellActivation`
map. It used to check only that the map existed, so an environment with
no activation commands was still offered for activation (the terminal
activate button and command-based auto-activation).

## Tests

- New tests in `utils.getShellActivationCommands.unit.test.ts`:
- no POSIX or `unknown` activation without an `activate` script, on
non-Windows and on Windows;
  - activation is still emitted when the script exists.
- New `src/test/features/common/activation.unit.test.ts` covers
`isActivatableEnvironment`, including the empty-map case.
- Two existing tests ("Bash activation does not include
Set-ExecutionPolicy" and "Windows unknown shell uses activate…") now
create the `activate` file they rely on.
- Unit tests (`tsc` + mocha, Node 22):
  - with the change: 2411 passing;
  - without it: the 3 new tests covering the bug fail.
- `eslint` and `prettier --check` are clean on the changed files.

I did not test this manually in VS Code with a real uv toolchain. The
fix is covered by the unit tests above.

This change was written with help from an AI coding assistant (Claude
Code). I reviewed and tested it as described above.

🤖 Generated with [Claude Code](https://claude.com/claude-code)

Co-authored-by: Claude Opus 5 <noreply@anthropic.com>

Author: Shubham-Padkonde

src/features/common/activation.ts

@@ -9,7 +9,7 @@ import {
 import { identifyTerminalShell } from './shellDetector';
 
 export function isActivatableEnvironment(environment: PythonEnvironment): boolean {
-    return !!environment.execInfo?.activation || !!environment.execInfo?.shellActivation;
+    return !!environment.execInfo?.activation || (environment.execInfo?.shellActivation?.size ?? 0) > 0;
 }
 
 export function isActivatedRunAvailable(environment: PythonEnvironment): boolean {

src/managers/common/utils.ts

@@ -115,30 +115,34 @@ export async function getShellActivationCommands(binDir: string): Promise<{
     const shellActivation: Map<string, PythonCommandRunConfiguration[]> = new Map();
     const shellDeactivation: Map<string, PythonCommandRunConfiguration[]> = new Map();
 
-    if (isWindows()) {
-        shellActivation.set('unknown', [{ executable: path.join(binDir, `activate`) }]);
-        shellDeactivation.set('unknown', [{ executable: path.join(binDir, `deactivate`) }]);
-    } else {
-        shellActivation.set('unknown', [{ executable: 'source', args: [path.join(binDir, `activate`)] }]);
-        shellDeactivation.set('unknown', [{ executable: 'deactivate' }]);
-    }
+    // Base interpreters (for example `uv python install` toolchains) share this layout but have no
+    // activation scripts, so only offer activation for scripts that exist, like the shells below.
+    if (await fs.pathExists(path.join(binDir, 'activate'))) {
+        if (isWindows()) {
+            shellActivation.set('unknown', [{ executable: path.join(binDir, `activate`) }]);
+            shellDeactivation.set('unknown', [{ executable: path.join(binDir, `deactivate`) }]);
+        } else {
+            shellActivation.set('unknown', [{ executable: 'source', args: [path.join(binDir, `activate`)] }]);
+            shellDeactivation.set('unknown', [{ executable: 'deactivate' }]);
+        }
 
-    shellActivation.set(ShellConstants.SH, [{ executable: 'source', args: [path.join(binDir, `activate`)] }]);
-    shellDeactivation.set(ShellConstants.SH, [{ executable: 'deactivate' }]);
+        shellActivation.set(ShellConstants.SH, [{ executable: 'source', args: [path.join(binDir, `activate`)] }]);
+        shellDeactivation.set(ShellConstants.SH, [{ executable: 'deactivate' }]);
 
-    shellActivation.set(ShellConstants.BASH, [{ executable: 'source', args: [path.join(binDir, `activate`)] }]);
-    shellDeactivation.set(ShellConstants.BASH, [{ executable: 'deactivate' }]);
+        shellActivation.set(ShellConstants.BASH, [{ executable: 'source', args: [path.join(binDir, `activate`)] }]);
+        shellDeactivation.set(ShellConstants.BASH, [{ executable: 'deactivate' }]);
 
-    shellActivation.set(ShellConstants.GITBASH, [
-        { executable: 'source', args: [pathForGitBash(path.join(binDir, `activate`))] },
-    ]);
-    shellDeactivation.set(ShellConstants.GITBASH, [{ executable: 'deactivate' }]);
+        shellActivation.set(ShellConstants.GITBASH, [
+            { executable: 'source', args: [pathForGitBash(path.join(binDir, `activate`))] },
+        ]);
+        shellDeactivation.set(ShellConstants.GITBASH, [{ executable: 'deactivate' }]);
 
-    shellActivation.set(ShellConstants.ZSH, [{ executable: 'source', args: [path.join(binDir, `activate`)] }]);
-    shellDeactivation.set(ShellConstants.ZSH, [{ executable: 'deactivate' }]);
+        shellActivation.set(ShellConstants.ZSH, [{ executable: 'source', args: [path.join(binDir, `activate`)] }]);
+        shellDeactivation.set(ShellConstants.ZSH, [{ executable: 'deactivate' }]);
 
-    shellActivation.set(ShellConstants.KSH, [{ executable: '.', args: [path.join(binDir, `activate`)] }]);
-    shellDeactivation.set(ShellConstants.KSH, [{ executable: 'deactivate' }]);
+        shellActivation.set(ShellConstants.KSH, [{ executable: '.', args: [path.join(binDir, `activate`)] }]);
+        shellDeactivation.set(ShellConstants.KSH, [{ executable: 'deactivate' }]);
+    }
 
     if (await fs.pathExists(path.join(binDir, 'Activate.ps1'))) {
         shellActivation.set(ShellConstants.PWSH, buildPwshActivationCommands(path.join(binDir, 'Activate.ps1')));

src/test/features/common/activation.unit.test.ts

@@ -0,0 +1,26 @@
+import assert from 'assert';
+import { PythonEnvironment } from '../../../api';
+import { isActivatableEnvironment } from '../../../features/common/activation';
+
+suite('isActivatableEnvironment', () => {
+    function env(execInfo: Partial<PythonEnvironment['execInfo']>): PythonEnvironment {
+        return { execInfo: { run: { executable: 'python' }, ...execInfo } } as PythonEnvironment;
+    }
+
+    test('Environment without activation is not activatable', () => {
+        assert.strictEqual(isActivatableEnvironment(env({})), false);
+    });
+
+    test('Environment with an empty shell activation map is not activatable', () => {
+        assert.strictEqual(isActivatableEnvironment(env({ shellActivation: new Map() })), false);
+    });
+
+    test('Environment with shell activation commands is activatable', () => {
+        const shellActivation = new Map([['bash', [{ executable: 'source', args: ['activate'] }]]]);
+        assert.strictEqual(isActivatableEnvironment(env({ shellActivation })), true);
+    });
+
+    test('Environment with an activation command is activatable', () => {
+        assert.strictEqual(isActivatableEnvironment(env({ activation: [{ executable: 'activate' }] })), true);
+    });
+});

src/test/managers/common/utils.getShellActivationCommands.unit.test.ts

@@ -89,7 +89,11 @@ suite('getShellActivationCommands', () => {
             const pwshActivation = result.shellActivation.get(ShellConstants.PWSH);
 
             assert.ok(pwshActivation, 'PowerShell activation should be defined');
-            assert.strictEqual(pwshActivation.length, 1, 'Should have only 1 command: activate (no Set-ExecutionPolicy)');
+            assert.strictEqual(
+                pwshActivation.length,
+                1,
+                'Should have only 1 command: activate (no Set-ExecutionPolicy)',
+            );
             assert.strictEqual(pwshActivation[0].executable, '&');
             assert.ok(pwshActivation[0].args);
             assert.ok(
@@ -106,7 +110,11 @@ suite('getShellActivationCommands', () => {
             const pwshActivation = result.shellActivation.get(ShellConstants.PWSH);
 
             assert.ok(pwshActivation, 'PowerShell activation should be defined');
-            assert.strictEqual(pwshActivation.length, 1, 'Should have only 1 command: activate (no Set-ExecutionPolicy)');
+            assert.strictEqual(
+                pwshActivation.length,
+                1,
+                'Should have only 1 command: activate (no Set-ExecutionPolicy)',
+            );
             assert.strictEqual(pwshActivation[0].executable, '&');
             assert.ok(pwshActivation[0].args);
             assert.ok(
@@ -131,6 +139,7 @@ suite('getShellActivationCommands', () => {
     suite('Other shells are not affected by execution policy change', () => {
         test('Bash activation does not include Set-ExecutionPolicy', async () => {
             isWindowsStub.returns(false);
+            await fs.writeFile(path.join(tmpDir, 'activate'), '');
 
             const result = await getShellActivationCommands(tmpDir);
             const bashActivation = result.shellActivation.get(ShellConstants.BASH);
@@ -156,6 +165,7 @@ suite('getShellActivationCommands', () => {
     suite('Windows unknown shell fallback', () => {
         test('Windows unknown shell uses activate without Set-ExecutionPolicy', async () => {
             isWindowsStub.returns(true);
+            await fs.writeFile(path.join(tmpDir, 'activate'), '');
 
             const result = await getShellActivationCommands(tmpDir);
             const unknownActivation = result.shellActivation.get('unknown');
@@ -165,4 +175,52 @@ suite('getShellActivationCommands', () => {
             assert.ok(unknownActivation[0].executable.endsWith('activate'));
         });
     });
+
+    suite('No activation without activation scripts', () => {
+        test('No POSIX shell activation when bin has no activate script (e.g. uv python toolchain)', async () => {
+            isWindowsStub.returns(false);
+            await fs.writeFile(path.join(tmpDir, 'python3'), '');
+
+            const result = await getShellActivationCommands(tmpDir);
+
+            for (const shell of [
+                'unknown',
+                ShellConstants.SH,
+                ShellConstants.BASH,
+                ShellConstants.GITBASH,
+                ShellConstants.ZSH,
+                ShellConstants.KSH,
+            ]) {
+                assert.strictEqual(result.shellActivation.get(shell), undefined, `${shell} should not be activated`);
+                assert.strictEqual(
+                    result.shellDeactivation.get(shell),
+                    undefined,
+                    `${shell} should not be deactivated`,
+                );
+            }
+            assert.strictEqual(result.shellActivation.size, 0);
+        });
+
+        test('No Windows unknown shell activation when Scripts has no activate script', async () => {
+            isWindowsStub.returns(true);
+
+            const result = await getShellActivationCommands(tmpDir);
+
+            assert.strictEqual(result.shellActivation.get('unknown'), undefined);
+            assert.strictEqual(result.shellActivation.size, 0);
+        });
+
+        test('POSIX shells are activated when the activate script exists', async () => {
+            isWindowsStub.returns(false);
+            await fs.writeFile(path.join(tmpDir, 'activate'), '');
+
+            const result = await getShellActivationCommands(tmpDir);
+
+            for (const shell of [ShellConstants.SH, ShellConstants.BASH, ShellConstants.ZSH]) {
+                assert.deepStrictEqual(result.shellActivation.get(shell), [
+                    { executable: 'source', args: [path.join(tmpDir, 'activate')] },
+                ]);
+            }
+        });
+    });
 });