Merge branch 'main' into anthonykim1/cleanOld

Author: anthonykim1

src/features/envCommands.ts

@@ -574,8 +574,10 @@ export async function runInTerminalCommand(
         const project = api.getPythonProject(uri);
         const environment = await api.getEnvironment(uri);
         if (environment && project) {
-            const terminal = await tm.getProjectTerminal(project, environment);
-            await runInTerminal(environment, terminal, {
+            const resolvedEnv = await api.resolveEnvironment(environment.environmentPath);
+            const envFinal = resolvedEnv ?? environment;
+            const terminal = await tm.getProjectTerminal(project, envFinal);
+            await runInTerminal(envFinal, terminal, {
                 cwd: project.uri,
                 args: [item.fsPath],
                 show: true,
@@ -594,9 +596,12 @@ export async function runInDedicatedTerminalCommand(
         const uri = item as Uri;
         const project = api.getPythonProject(uri);
         const environment = await api.getEnvironment(uri);
+
         if (environment && project) {
-            const terminal = await tm.getDedicatedTerminal(item, project, environment);
-            await runInTerminal(environment, terminal, {
+            const resolvedEnv = await api.resolveEnvironment(environment.environmentPath);
+            const envFinal = resolvedEnv ?? environment;
+            const terminal = await tm.getDedicatedTerminal(item, project, envFinal);
+            await runInTerminal(envFinal, terminal, {
                 cwd: project.uri,
                 args: [item.fsPath],
                 show: true,
@@ -612,8 +617,10 @@ export async function runAsTaskCommand(item: unknown, api: PythonEnvironmentApi)
         const project = api.getPythonProject(uri);
         const environment = await api.getEnvironment(uri);
         if (environment) {
+            const resolvedEnv = await api.resolveEnvironment(environment.environmentPath);
+            const envFinal = resolvedEnv ?? environment;
             return await runAsTask(
-                environment,
+                envFinal,
                 {
                     project,
                     args: [item.fsPath],

src/features/execution/execUtils.ts

@@ -1,10 +1,10 @@
-export function quoteArg(arg: string): string {
+export function quoteStringIfNecessary(arg: string): string {
     if (arg.indexOf(' ') >= 0 && !(arg.startsWith('"') && arg.endsWith('"'))) {
         return `"${arg}"`;
     }
     return arg;
 }
 
 export function quoteArgs(args: string[]): string[] {
-    return args.map(quoteArg);
+    return args.map(quoteStringIfNecessary);
 }

src/features/execution/runAsTask.ts

@@ -9,9 +9,10 @@ import {
     WorkspaceFolder,
 } from 'vscode';
 import { PythonEnvironment, PythonTaskExecutionOptions } from '../../api';
+import { traceInfo, traceWarn } from '../../common/logging';
 import { executeTask } from '../../common/tasks.apis';
 import { getWorkspaceFolder } from '../../common/workspace.apis';
-import { quoteArg } from './execUtils';
+import { quoteStringIfNecessary } from './execUtils';
 
 function getWorkspaceFolderOrDefault(uri?: Uri): WorkspaceFolder | TaskScope {
     const workspace = uri ? getWorkspaceFolder(uri) : undefined;
@@ -25,10 +26,17 @@ export async function runAsTask(
 ): Promise<TaskExecution> {
     const workspace: WorkspaceFolder | TaskScope = getWorkspaceFolderOrDefault(options.project?.uri);
 
-    let executable = environment.execInfo?.activatedRun?.executable ?? environment.execInfo?.run.executable ?? 'python';
-    executable = quoteArg(executable);
+    let executable = environment.execInfo?.activatedRun?.executable ?? environment.execInfo?.run.executable;
+    if (!executable) {
+        traceWarn('No Python executable found in environment; falling back to "python".');
+        executable = 'python';
+    }
+    // Check and quote the executable path if necessary
+    executable = quoteStringIfNecessary(executable);
+
     const args = environment.execInfo?.activatedRun?.args ?? environment.execInfo?.run.args ?? [];
     const allArgs = [...args, ...options.args];
+    traceInfo(`Running as task: ${executable} ${allArgs.join(' ')}`);
 
     const task = new Task(
         { type: 'python' },

src/features/execution/runInBackground.ts

@@ -1,14 +1,22 @@
 import * as cp from 'child_process';
-import { PythonEnvironment, PythonBackgroundRunOptions, PythonProcess } from '../../api';
+import { PythonBackgroundRunOptions, PythonEnvironment, PythonProcess } from '../../api';
+import { traceError, traceInfo, traceWarn } from '../../common/logging';
+import { quoteStringIfNecessary } from './execUtils';
 
 export async function runInBackground(
     environment: PythonEnvironment,
     options: PythonBackgroundRunOptions,
 ): Promise<PythonProcess> {
-    const executable =
-        environment.execInfo?.activatedRun?.executable ?? environment.execInfo?.run.executable ?? 'python';
+    let executable = environment.execInfo?.activatedRun?.executable ?? environment.execInfo?.run.executable;
+    if (!executable) {
+        traceWarn('No Python executable found in environment; falling back to "python".');
+        executable = 'python';
+    }
+    // Check and quote the executable path if necessary
+    executable = quoteStringIfNecessary(executable);
     const args = environment.execInfo?.activatedRun?.args ?? environment.execInfo?.run.args ?? [];
     const allArgs = [...args, ...options.args];
+    traceInfo(`Running in background: ${executable} ${allArgs.join(' ')}`);
 
     const proc = cp.spawn(executable, allArgs, { stdio: 'pipe', cwd: options.cwd, env: options.env });
 
@@ -22,8 +30,17 @@ export async function runInBackground(
                 proc.kill();
             }
         },
-        onExit: (listener: (code: number | null, signal: NodeJS.Signals | null) => void) => {
-            proc.on('exit', listener);
+        onExit: (listener: (code: number | null, signal: NodeJS.Signals | null, error?: Error | null) => void) => {
+            proc.on('exit', (code, signal) => {
+                if (code && code !== 0) {
+                    traceError(`Process exited with error code: ${code}, signal: ${signal}`);
+                }
+                listener(code, signal, null);
+            });
+            proc.on('error', (error) => {
+                traceError(`Process error: ${error?.message || error}${error?.stack ? '\n' + error.stack : ''}`);
+                listener(null, null, error);
+            });
         },
     };
 }

src/features/terminal/shells/bash/bashStartup.ts

@@ -71,10 +71,10 @@ async function isStartupSetup(profile: string, key: string): Promise<ShellSetupS
 
 async function setupStartup(profile: string, key: string, name: string): Promise<boolean> {
     if (shellIntegrationForActiveTerminal(name, profile)) {
+        removeStartup(profile, key);
         return true;
     }
     const activationContent = getActivationContent(key);
-
     try {
         if (await fs.pathExists(profile)) {
             const content = await fs.readFile(profile, 'utf8');

src/features/terminal/shells/fish/fishStartup.ts

@@ -59,6 +59,7 @@ async function isStartupSetup(profilePath: string, key: string): Promise<boolean
 async function setupStartup(profilePath: string, key: string): Promise<boolean> {
     try {
         if (shellIntegrationForActiveTerminal('fish', profilePath)) {
+            removeFishStartup(profilePath, key);
             return true;
         }
         const activationContent = getActivationContent(key);

src/features/terminal/shells/pwsh/pwshStartup.ts

@@ -146,6 +146,7 @@ async function isPowerShellStartupSetup(shell: string, profile: string): Promise
 
 async function setupPowerShellStartup(shell: string, profile: string): Promise<boolean> {
     if (shellIntegrationForActiveTerminal(shell, profile)) {
+        removePowerShellStartup(shell, profile);
         return true;
     }
     const activationContent = getActivationContent();