Merge branch 'main' into copilot/fix-python-environment-creation

eleanorjboyd · web-flow · commit 19fc3df9a999 · 2025-10-27T18:45:37.000-07:00
diff --git a/.github/instructions/testing-workflow.instructions.md b/.github/instructions/testing-workflow.instructions.md
@@ -548,5 +548,6 @@ envConfig.inspect
 -   When fixing mock environment creation, use `null` to truly omit properties rather than `undefined` (1)
 -   Always recompile TypeScript after making import/export changes before running tests, as stubs won't work if they're applied to old compiled JavaScript that doesn't have the updated imports (2)
 -   Create proxy abstraction functions for Node.js APIs like `cp.spawn` to enable clean testing - use function overloads to preserve Node.js's intelligent typing while making the functions mockable (1)
+-   When a targeted test run yields 0 tests, first verify the compiled JS exists under `out/test` (rootDir is `src`); absence almost always means the test file sits outside `src` or compilation hasn't run yet (1)
 -   When unit tests fail with VS Code API errors like `TypeError: X is not a constructor` or `Cannot read properties of undefined (reading 'Y')`, check if VS Code APIs are properly mocked in `/src/test/unittests.ts` - add missing Task-related APIs (`Task`, `TaskScope`, `ShellExecution`, `TaskRevealKind`, `TaskPanelKind`) and namespace mocks (`tasks`) following the existing pattern of `mockedVSCode.X = vscodeMocks.vscMockExtHostedTypes.X` (1)
 -   Create minimal mock objects with only required methods and use TypeScript type assertions (e.g., mockApi as PythonEnvironmentApi) to satisfy interface requirements instead of implementing all interface methods when only specific methods are needed for the test (1)
diff --git a/eslint.config.mjs b/eslint.config.mjs
@@ -35,6 +35,6 @@ export default [{
         eqeqeq: "warn",
         "no-throw-literal": "warn",
         semi: "warn",
-        "@typescript-eslint/no-explicit-any": "warn",
+        "@typescript-eslint/no-explicit-any": "error",
     },
 }];
diff --git a/examples/sample1/src/api.ts b/examples/sample1/src/api.ts
@@ -650,7 +650,6 @@ export interface PythonProject {
      * The tooltip for the Python project, which can be a string or a Markdown string.
      */
     readonly tooltip?: string | MarkdownString;
-
 }
 
 /**
@@ -692,7 +691,6 @@ export interface PythonProjectCreator {
      */
     readonly tooltip?: string | MarkdownString;
 
-
     /**
      * Creates a new Python project or projects.
      * @param options - Optional parameters for creating the Python project.
@@ -1228,12 +1226,13 @@ export interface PythonEnvironmentVariablesApi {
      * 3. `.env` file at the root of the python project.
      * 4. `overrides` in the order provided.
      *
-     * @param uri The URI of the project, workspace or a file in a for which environment variables are required.
+     * @param uri The URI of the project, workspace or a file in a for which environment variables are required. If not provided,
+     * it fetches the environment variables for the global scope.
      * @param overrides Additional environment variables to override the defaults.
      * @param baseEnvVar The base environment variables that should be used as a starting point.
      */
     getEnvironmentVariables(
-        uri: Uri,
+        uri: Uri | undefined,
         overrides?: ({ [key: string]: string | undefined } | Uri)[],
         baseEnvVar?: { [key: string]: string | undefined },
     ): Promise<{ [key: string]: string | undefined }>;
diff --git a/package.json b/package.json
@@ -12,7 +12,8 @@
         "Other"
     ],
     "enabledApiProposals": [
-        "terminalShellEnv"
+        "terminalShellEnv",
+        "terminalDataWriteEvent"
     ],
     "capabilities": {
         "untrustedWorkspaces": {
diff --git a/src/api.ts b/src/api.ts
@@ -1237,12 +1237,13 @@ export interface PythonEnvironmentVariablesApi {
      * 3. `.env` file at the root of the python project.
      * 4. `overrides` in the order provided.
      *
-     * @param uri The URI of the project, workspace or a file in a for which environment variables are required.
+     * @param uri The URI of the project, workspace or a file in a for which environment variables are required.If not provided,
+     * it fetches the environment variables for the global scope.
      * @param overrides Additional environment variables to override the defaults.
      * @param baseEnvVar The base environment variables that should be used as a starting point.
      */
     getEnvironmentVariables(
-        uri: Uri,
+        uri: Uri | undefined,
         overrides?: ({ [key: string]: string | undefined } | Uri)[],
         baseEnvVar?: { [key: string]: string | undefined },
     ): Promise<{ [key: string]: string | undefined }>;
diff --git a/src/common/utils/asyncUtils.ts b/src/common/utils/asyncUtils.ts
@@ -1,3 +1,3 @@
-export async function sleep(milliseconds: number) {
+export async function timeout(milliseconds: number): Promise<void> {
     return new Promise<void>((resolve) => setTimeout(resolve, milliseconds));
 }
diff --git a/src/common/utils/debounce.ts b/src/common/utils/debounce.ts
@@ -1,20 +1,27 @@
-export interface SimpleDebounce {
+import { Disposable } from 'vscode';
+export interface SimpleDebounce extends Disposable {
     trigger(): void;
 }
 
-class SimpleDebounceImpl {
+class SimpleDebounceImpl implements SimpleDebounce {
     private timeout: NodeJS.Timeout | undefined;
 
     constructor(private readonly ms: number, private readonly callback: () => void) {}
 
-    public trigger() {
+    public trigger(): void {
         if (this.timeout) {
             clearTimeout(this.timeout);
         }
         this.timeout = setTimeout(() => {
             this.callback();
         }, this.ms);
     }
+
+    public dispose(): void {
+        if (this.timeout) {
+            clearTimeout(this.timeout);
+        }
+    }
 }
 
 export function createSimpleDebounce(ms: number, callback: () => void): SimpleDebounce {
diff --git a/src/common/window.apis.ts b/src/common/window.apis.ts
@@ -49,6 +49,14 @@ export function onDidChangeTerminalShellIntegration(
     return window.onDidChangeTerminalShellIntegration(listener, thisArgs, disposables);
 }
 
+export function onDidWriteTerminalData(
+    listener: (e: { readonly terminal: Terminal; readonly data: string }) => any,
+    thisArgs?: any,
+    disposables?: Disposable[],
+): Disposable {
+    return window.onDidWriteTerminalData(listener, thisArgs, disposables);
+}
+
 export function showOpenDialog(options?: OpenDialogOptions): Thenable<Uri[] | undefined> {
     return window.showOpenDialog(options);
 }
diff --git a/src/features/execution/envVariableManager.ts b/src/features/execution/envVariableManager.ts
@@ -37,11 +37,11 @@ export class PythonEnvVariableManager implements EnvVarManager {
     }
 
     async getEnvironmentVariables(
-        uri: Uri,
+        uri: Uri | undefined,
         overrides?: ({ [key: string]: string | undefined } | Uri)[],
         baseEnvVar?: { [key: string]: string | undefined },
     ): Promise<{ [key: string]: string | undefined }> {
-        const project = this.pm.get(uri);
+        const project = uri ? this.pm.get(uri) : undefined;
 
         const base = baseEnvVar || { ...process.env };
         let env = base;
diff --git a/src/features/terminal/shells/common/shellUtils.ts b/src/features/terminal/shells/common/shellUtils.ts
@@ -1,7 +1,7 @@
 import { PythonCommandRunConfiguration, PythonEnvironment } from '../../../../api';
 import { traceInfo } from '../../../../common/logging';
 import { getGlobalPersistentState } from '../../../../common/persistentState';
-import { sleep } from '../../../../common/utils/asyncUtils';
+import { timeout } from '../../../../common/utils/asyncUtils';
 import { isWindows } from '../../../../common/utils/platformUtils';
 import { activeTerminalShellIntegration } from '../../../../common/window.apis';
 import { getConfiguration } from '../../../../common/workspace.apis';
@@ -106,11 +106,11 @@ export function extractProfilePath(content: string): string | undefined {
 
 export async function shellIntegrationForActiveTerminal(name: string, profile?: string): Promise<boolean> {
     let hasShellIntegration = activeTerminalShellIntegration();
-    let timeout = 0;
+    let timeOutstamp = 0;
 
-    while (!hasShellIntegration && timeout < SHELL_INTEGRATION_TIMEOUT) {
-        await sleep(SHELL_INTEGRATION_POLL_INTERVAL);
-        timeout += SHELL_INTEGRATION_POLL_INTERVAL;
+    while (!hasShellIntegration && timeOutstamp < SHELL_INTEGRATION_TIMEOUT) {
+        await timeout(SHELL_INTEGRATION_POLL_INTERVAL);
+        timeOutstamp += SHELL_INTEGRATION_POLL_INTERVAL;
         hasShellIntegration = activeTerminalShellIntegration();
     }
 
diff --git a/src/features/terminal/terminalManager.ts b/src/features/terminal/terminalManager.ts
@@ -309,18 +309,8 @@ export class TerminalManagerImpl implements TerminalManager {
         // https://github.com/microsoft/vscode-python-environments/issues/172
         // const name = options.name ?? `Python: ${environment.displayName}`;
         const newTerminal = createTerminal({
-            name: options.name,
-            shellPath: options.shellPath,
-            shellArgs: options.shellArgs,
-            cwd: options.cwd,
+            ...options,
             env: envVars,
-            strictEnv: options.strictEnv,
-            message: options.message,
-            iconPath: options.iconPath,
-            hideFromUser: options.hideFromUser,
-            color: options.color,
-            location: options.location,
-            isTransient: options.isTransient,
         });
 
         if (autoActType === ACT_TYPE_COMMAND) {
diff --git a/src/features/terminal/utils.ts b/src/features/terminal/utils.ts
@@ -1,19 +1,123 @@
 import * as path from 'path';
-import { Terminal, TerminalOptions, Uri } from 'vscode';
+import { Disposable, env, Terminal, TerminalOptions, Uri } from 'vscode';
 import { PythonEnvironment, PythonProject, PythonProjectEnvironmentApi, PythonProjectGetterApi } from '../../api';
-import { sleep } from '../../common/utils/asyncUtils';
+import { timeout } from '../../common/utils/asyncUtils';
+import { createSimpleDebounce } from '../../common/utils/debounce';
+import { onDidChangeTerminalShellIntegration, onDidWriteTerminalData } from '../../common/window.apis';
 import { getConfiguration, getWorkspaceFolders } from '../../common/workspace.apis';
 
 export const SHELL_INTEGRATION_TIMEOUT = 500; // 0.5 seconds
 export const SHELL_INTEGRATION_POLL_INTERVAL = 20; // 0.02 seconds
 
+/**
+ * Three conditions in a Promise.race:
+ * 1. Timeout based on VS Code's terminal.integrated.shellIntegration.timeout setting
+ * 2. Shell integration becoming available (window.onDidChangeTerminalShellIntegration event)
+ * 3. Detection of common prompt patterns in terminal output
+ */
 export async function waitForShellIntegration(terminal: Terminal): Promise<boolean> {
-    let timeout = 0;
-    while (!terminal.shellIntegration && timeout < SHELL_INTEGRATION_TIMEOUT) {
-        await sleep(SHELL_INTEGRATION_POLL_INTERVAL);
-        timeout += SHELL_INTEGRATION_POLL_INTERVAL;
+    if (terminal.shellIntegration) {
+        return true;
+    }
+
+    const config = getConfiguration('terminal.integrated');
+    const shellIntegrationEnabled = config.get<boolean>('shellIntegration.enabled', true);
+    const timeoutValue = config.get<number | undefined>('shellIntegration.timeout');
+    const isRemote = env.remoteName !== undefined;
+    let timeoutMs: number;
+    if (typeof timeoutValue !== 'number' || timeoutValue < 0) {
+        timeoutMs = shellIntegrationEnabled ? 5000 : isRemote ? 3000 : 2000;
+    } else {
+        timeoutMs = Math.max(timeoutValue, 500);
+    }
+
+    const disposables: Disposable[] = [];
+
+    try {
+        const result = await Promise.race([
+            // Condition 1: Shell integration timeout setting
+            timeout(timeoutMs).then(() => false),
+
+            // Condition 2: Shell integration becomes available
+            new Promise<boolean>((resolve) => {
+                disposables.push(
+                    onDidChangeTerminalShellIntegration((e) => {
+                        if (e.terminal === terminal) {
+                            resolve(true);
+                        }
+                    }),
+                );
+            }),
+
+            // Condition 3: Detect prompt patterns in terminal output
+            new Promise<boolean>((resolve) => {
+                const dataEvents: string[] = [];
+                const debounced = createSimpleDebounce(50, () => {
+                    if (dataEvents && detectsCommonPromptPattern(dataEvents.join(''))) {
+                        resolve(false);
+                    }
+                });
+                disposables.push(debounced);
+                disposables.push(
+                    onDidWriteTerminalData((e) => {
+                        if (e.terminal === terminal) {
+                            dataEvents.push(e.data);
+                            debounced.trigger();
+                        }
+                    }),
+                );
+            }),
+        ]);
+
+        return result;
+    } finally {
+        disposables.forEach((d) => d.dispose());
     }
-    return terminal.shellIntegration !== undefined;
+}
+
+// Detects if the given text content appears to end with a common prompt pattern.
+function detectsCommonPromptPattern(terminalData: string): boolean {
+    if (terminalData.trim().length === 0) {
+        return false;
+    }
+
+    const sanitizedTerminalData = removeAnsiEscapeCodes(terminalData);
+    // PowerShell prompt: PS C:\> or similar patterns
+    if (/PS\s+[A-Z]:\\.*>\s*$/.test(sanitizedTerminalData)) {
+        return true;
+    }
+
+    // Command Prompt: C:\path>
+    if (/^[A-Z]:\\.*>\s*$/.test(sanitizedTerminalData)) {
+        return true;
+    }
+
+    // Bash-style prompts ending with $
+    if (/\$\s*$/.test(sanitizedTerminalData)) {
+        return true;
+    }
+
+    // Root prompts ending with #
+    if (/#\s*$/.test(sanitizedTerminalData)) {
+        return true;
+    }
+
+    // Python REPL prompt
+    if (/^>>>\s*$/.test(sanitizedTerminalData)) {
+        return true;
+    }
+
+    // Custom prompts ending with the starship character (\u276f)
+    if (/\u276f\s*$/.test(sanitizedTerminalData)) {
+        return true;
+    }
+
+    // Generic prompts ending with common prompt characters
+    if (/[>%]\s*$/.test(sanitizedTerminalData)) {
+        return true;
+    }
+
+    return false;
 }
 
 export function isTaskTerminal(terminal: Terminal): boolean {
@@ -171,3 +275,28 @@ export async function getAllDistinctProjectEnvironments(
 
     return envs.length > 0 ? envs : undefined;
 }
+
+// Defacto standard: https://invisible-island.net/xterm/ctlseqs/ctlseqs.html
+const CSI_SEQUENCE = /(?:\x1b\[|\x9b)[=?>!]?[\d;:]*["$#'* ]?[a-zA-Z@^`{}|~]/;
+const OSC_SEQUENCE = /(?:\x1b\]|\x9d).*?(?:\x1b\\|\x07|\x9c)/;
+const ESC_SEQUENCE = /\x1b(?:[ #%\(\)\*\+\-\.\/]?[a-zA-Z0-9\|}~@])/;
+const CONTROL_SEQUENCES = new RegExp(
+    '(?:' + [CSI_SEQUENCE.source, OSC_SEQUENCE.source, ESC_SEQUENCE.source].join('|') + ')',
+    'g',
+);
+
+/**
+ * Strips ANSI escape sequences from a string.
+ * @param str The dastringa stringo strip the ANSI escape sequences from.
+ *
+ * @example
+ * removeAnsiEscapeCodes('\u001b[31mHello, World!\u001b[0m');
+ * // 'Hello, World!'
+ */
+export function removeAnsiEscapeCodes(str: string): string {
+    if (str) {
+        str = str.replace(CONTROL_SEQUENCES, '');
+    }
+
+    return str;
+}
diff --git a/src/managers/common/utils.ts b/src/managers/common/utils.ts
@@ -13,6 +13,14 @@ export function noop() {
     // do nothing
 }
 
+/**
+ * In **contrast** to just checking `typeof` this will return `false` for `NaN`.
+ * @returns whether the provided parameter is a JavaScript Number or not.
+ */
+export function isNumber(obj: unknown): obj is number {
+    return typeof obj === 'number' && !isNaN(obj);
+}
+
 export function shortVersion(version: string): string {
     const pattern = /(\d)\.(\d+)(?:\.(\d+)?)?/gm;
     const match = pattern.exec(version);
diff --git a/src/test/features/creators/autoFindProjects.unit.test.ts b/src/test/features/creators/autoFindProjects.unit.test.ts
@@ -1,15 +1,15 @@
+import assert from 'assert';
 import * as path from 'path';
 import * as sinon from 'sinon';
 import * as typmoq from 'typemoq';
-import * as wapi from '../../../common/workspace.apis';
-import * as winapi from '../../../common/window.apis';
-import { PythonProjectManager } from '../../../internal.api';
-import { createDeferred } from '../../../common/utils/deferred';
-import { AutoFindProjects } from '../../../features/creators/autoFindProjects';
-import assert from 'assert';
 import { Uri } from 'vscode';
 import { PythonProject } from '../../../api';
-import { sleep } from '../../../common/utils/asyncUtils';
+import { timeout } from '../../../common/utils/asyncUtils';
+import { createDeferred } from '../../../common/utils/deferred';
+import * as winapi from '../../../common/window.apis';
+import * as wapi from '../../../common/workspace.apis';
+import { AutoFindProjects } from '../../../features/creators/autoFindProjects';
+import { PythonProjectManager } from '../../../internal.api';
 
 suite('Auto Find Project tests', () => {
     let findFilesStub: sinon.SinonStub;
@@ -45,7 +45,7 @@ suite('Auto Find Project tests', () => {
         const result = await autoFindProjects.create();
         assert.equal(result, undefined, 'Result should be undefined');
 
-        await Promise.race([deferred.promise, sleep(100)]);
+        await Promise.race([deferred.promise, timeout(100)]);
         assert.ok(errorShown, 'Error message should have been shown');
     });
 
@@ -64,7 +64,7 @@ suite('Auto Find Project tests', () => {
         const result = await autoFindProjects.create();
         assert.equal(result, undefined, 'Result should be undefined');
 
-        await Promise.race([deferred.promise, sleep(100)]);
+        await Promise.race([deferred.promise, timeout(100)]);
         assert.ok(errorShown, 'Error message should have been shown');
     });
 
diff --git a/src/test/features/execution/execUtils.unit.test.ts b/src/test/features/execution/execUtils.unit.test.ts
diff --git a/src/test/features/terminalEnvVarInjectorBasic.unit.test.ts b/src/test/features/terminalEnvVarInjectorBasic.unit.test.ts
diff --git a/src/vscode.proposed.terminalDataWriteEvent.d.ts b/src/vscode.proposed.terminalDataWriteEvent.d.ts

Original file line number	Diff line number	Diff line change
`@@ -1,3 +1,3 @@`
`1`		`-export async function sleep(milliseconds: number) {`
	`1`	`+export async function timeout(milliseconds: number): Promise<void> {`
`2`	`2`	`return new Promise<void>((resolve) => setTimeout(resolve, milliseconds));`
`3`	`3`	`}`
Original file line number	Diff line number	Diff line change
`@@ -49,6 +49,14 @@ export function onDidChangeTerminalShellIntegration(`
`49`	`49`	`return window.onDidChangeTerminalShellIntegration(listener, thisArgs, disposables);`
`50`	`50`	`}`
`51`	`51`
	`52`	`+export function onDidWriteTerminalData(`
	`53`	`+ listener: (e: { readonly terminal: Terminal; readonly data: string }) => any,`
	`54`	`+ thisArgs?: any,`
	`55`	`+ disposables?: Disposable[],`
	`56`	`+): Disposable {`
	`57`	`+ return window.onDidWriteTerminalData(listener, thisArgs, disposables);`
	`58`	`+}`
	`59`	`+`
`52`	`60`	`export function showOpenDialog(options?: OpenDialogOptions): Thenable<Uri[] \| undefined> {`
`53`	`61`	`return window.showOpenDialog(options);`
`54`	`62`	`}`