fix: Do not activate on pseudoterminals

Currently the extension gets activated on pseudoterminals as the current check for not user-facing terminals does not catch this case. These terminals should be skipped during activation as to avoid unexpected commands and behavior.

Author: edvilme

src/features/terminal/terminalActivationState.ts

@@ -11,7 +11,7 @@ import { PythonEnvironment } from '../../api';
 import { traceError, traceInfo, traceVerbose } from '../../common/logging';
 import { onDidEndTerminalShellExecution, onDidStartTerminalShellExecution } from '../../common/window.apis';
 import { getActivationCommand, getDeactivationCommand } from '../common/activation';
-import { getShellIntegrationTimeout, isTaskTerminal } from './utils';
+import { getShellIntegrationTimeout, isTaskTerminal, shouldSkipTerminalActivation } from './utils';
 
 export interface DidChangeTerminalActivationStateEvent {
     terminal: Terminal;
@@ -86,6 +86,11 @@ export class TerminalActivationImpl implements TerminalActivationInternal {
     }
 
     async activate(terminal: Terminal, environment: PythonEnvironment): Promise<void> {
+        if (shouldSkipTerminalActivation(terminal)) {
+            traceVerbose('Skipping activation for this terminal');
+            return;
+        }
+
         if (isTaskTerminal(terminal)) {
             traceVerbose('Cannot activate environment in a task terminal');
             return;

src/features/terminal/terminalManager.ts

@@ -1,6 +1,6 @@
 import * as fsapi from 'fs-extra';
 import * as path from 'path';
-import { Disposable, EventEmitter, ProgressLocation, Terminal, TerminalOptions, Uri } from 'vscode';
+import { Disposable, EventEmitter, ProgressLocation, Terminal, Uri } from 'vscode';
 import { PythonEnvironment, PythonEnvironmentApi, PythonProject, PythonTerminalCreateOptions } from '../../api';
 import { ActivationStrings } from '../../common/localize';
 import { traceInfo, traceVerbose } from '../../common/logging';
@@ -34,6 +34,7 @@ import {
     getAutoActivationType,
     getEnvironmentForTerminal,
     shouldActivateInCurrentTerminal,
+    shouldSkipTerminalActivation,
     waitForShellIntegration,
 } from './utils';
 
@@ -94,7 +95,7 @@ export class TerminalManagerImpl implements TerminalManager {
                 this.onTerminalClosedEmitter.fire(t);
             }),
             this.onTerminalOpened(async (t) => {
-                if (this.skipActivationOnOpen.has(t) || (t.creationOptions as TerminalOptions)?.hideFromUser) {
+                if (this.skipActivationOnOpen.has(t) || shouldSkipTerminalActivation(t)) {
                     return;
                 }
                 let env = this.ta.getEnvironment(t);
@@ -419,7 +420,11 @@ export class TerminalManagerImpl implements TerminalManager {
 
         if (actType === ACT_TYPE_COMMAND) {
             if (!skipPreExistingTerminals) {
-                await Promise.all(terminals().map(async (t) => this.activateUsingCommand(api, t)));
+                await Promise.all(
+                    terminals()
+                        .filter((t) => !shouldSkipTerminalActivation(t))
+                        .map(async (t) => this.activateUsingCommand(api, t)),
+                );
             }
         } else if (actType === ACT_TYPE_SHELL) {
             const shells = new Set(
@@ -431,12 +436,14 @@ export class TerminalManagerImpl implements TerminalManager {
                 await this.handleSetupCheck(shells);
                 if (!skipPreExistingTerminals) {
                     await Promise.all(
-                        terminals().map(async (t) => {
-                            // If the shell is not set up, we activate using command fallback.
-                            if (this.shellSetup.get(identifyTerminalShell(t)) === false) {
-                                await this.activateUsingCommand(api, t);
-                            }
-                        }),
+                        terminals()
+                            .filter((t) => !shouldSkipTerminalActivation(t))
+                            .map(async (t) => {
+                                // If the shell is not set up, we activate using command fallback.
+                                if (this.shellSetup.get(identifyTerminalShell(t)) === false) {
+                                    await this.activateUsingCommand(api, t);
+                                }
+                            }),
                     );
                 }
             }

src/features/terminal/utils.ts

@@ -1,5 +1,5 @@
 import * as path from 'path';
-import { Disposable, env, tasks, Terminal, TerminalOptions, Uri } from 'vscode';
+import { Disposable, env, ExtensionTerminalOptions, tasks, Terminal, TerminalOptions, Uri } from 'vscode';
 import { PythonEnvironment, PythonProject, PythonProjectEnvironmentApi, PythonProjectGetterApi } from '../../api';
 import { timeout } from '../../common/utils/asyncUtils';
 import { createSimpleDebounce } from '../../common/utils/debounce';
@@ -355,3 +355,16 @@ export function removeAnsiEscapeCodes(str: string): string {
 
     return str;
 }
+
+/**
+ * Determines if a terminal should be skipped for environment activation based on its creation options.
+ * Terminals that are hidden from the user or are PTY-based extension terminals are skipped.
+ * @param terminal The terminal to check.
+ * @returns `true` if the terminal should be skipped; `false` otherwise.
+ */
+export function shouldSkipTerminalActivation(terminal: Terminal): boolean {
+    return (
+        !!(terminal.creationOptions as TerminalOptions)?.hideFromUser ||
+        !!(terminal.creationOptions as ExtensionTerminalOptions)?.pty
+    );
+}