fix: add markers to extract shell profile path

Author: karthiknadig

src/features/terminal/shells/common/shellUtils.ts

@@ -78,3 +78,17 @@ export function getShellDeactivationCommand(
 
     return deactivation;
 }
+
+export const PROFILE_TAG_START = '###VSCODE_PROFILE_PATH_START###';
+export const PROFILE_TAG_END = '###VSCODE_PROFILE_PATH_END###';
+export function extractProfilePath(content: string): string | undefined {
+    // Extract only the part between the tags
+    const profilePathRegex = new RegExp(`${PROFILE_TAG_START}\\r?\\n(.*?)\\r?\\n${PROFILE_TAG_END}`, 's');
+    const match = content?.match(profilePathRegex);
+
+    if (match && match[1]) {
+        const extractedPath = match[1].trim();
+        return extractedPath;
+    }
+    return undefined;
+}

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

@@ -9,6 +9,7 @@ import { runCommand } from '../utils';
 
 import { ShellConstants } from '../../../common/shellConstants';
 import { hasStartupCode, insertStartupCode, removeStartupCode } from '../common/editUtils';
+import { extractProfilePath, PROFILE_TAG_END, PROFILE_TAG_START } from '../common/shellUtils';
 import { POWERSHELL_ENV_KEY } from './pwshConstants';
 
 async function isPowerShellInstalled(shell: string): Promise<boolean> {
@@ -23,13 +24,18 @@ async function isPowerShellInstalled(shell: string): Promise<boolean> {
 
 async function getProfileForShell(shell: 'powershell' | 'pwsh'): Promise<string> {
     try {
-        const profilePath = await runCommand(
-            isWindows() ? `${shell} -Command $profile` : `${shell} -Command \\$profile`,
+        const content = await runCommand(
+            isWindows()
+                ? `${shell} -Command "Write-Output '${PROFILE_TAG_START}'; Write-Output $profile; Write-Output '${PROFILE_TAG_END}'"`
+                : `${shell} -Command "Write-Output '${PROFILE_TAG_START}'; Write-Output \\$profile; Write-Output '${PROFILE_TAG_END}'"`,
         );
-        traceInfo(`SHELL: ${shell} profile found at: ${profilePath}`);
 
-        if (profilePath) {
-            return profilePath.trim();
+        if (content) {
+            const profilePath = extractProfilePath(content);
+            if (profilePath) {
+                traceInfo(`SHELL: ${shell} profile found at: ${profilePath}`);
+                return profilePath;
+            }
         }
     } catch (err) {
         traceError(`${shell} failed to get profile path`, err);

src/test/features/terminal/shells/common/shellUtils.unit.test.ts

@@ -0,0 +1,80 @@
+import * as assert from 'assert';
+import {
+    extractProfilePath,
+    PROFILE_TAG_END,
+    PROFILE_TAG_START,
+} from '../../../../../features/terminal/shells/common/shellUtils';
+
+suite('Shell Utils', () => {
+    suite('extractProfilePath', () => {
+        test('should return undefined when content is empty', () => {
+            const content = '';
+            const result = extractProfilePath(content);
+            assert.strictEqual(result, undefined);
+        });
+
+        test('should return undefined when content does not have tags', () => {
+            const content = 'sample content without tags';
+            const result = extractProfilePath(content);
+            assert.strictEqual(result, undefined);
+        });
+
+        test('should return undefined when only start tag exists', () => {
+            const content = `content\n${PROFILE_TAG_START}\nsome path`;
+            const result = extractProfilePath(content);
+            assert.strictEqual(result, undefined);
+        });
+
+        test('should return undefined when only end tag exists', () => {
+            const content = `content\nsome path\n${PROFILE_TAG_END}`;
+            const result = extractProfilePath(content);
+            assert.strictEqual(result, undefined);
+        });
+
+        test('should return undefined when tags are in wrong order', () => {
+            const content = `content\n${PROFILE_TAG_END}\nsome path\n${PROFILE_TAG_START}`;
+            const result = extractProfilePath(content);
+            assert.strictEqual(result, undefined);
+        });
+        test('should return undefined when content between tags is empty', () => {
+            const content = `content\n${PROFILE_TAG_START}\n\n${PROFILE_TAG_END}\nmore content`;
+            const result = extractProfilePath(content);
+            assert.strictEqual(result, undefined);
+        });
+
+        test('should extract path when found between tags', () => {
+            const expectedPath = '/usr/local/bin/python';
+            const content = `content\n${PROFILE_TAG_START}\n${expectedPath}\n${PROFILE_TAG_END}\nmore content`;
+            const result = extractProfilePath(content);
+            assert.strictEqual(result, expectedPath);
+        });
+
+        test('should trim whitespace from extracted path', () => {
+            const expectedPath = '/usr/local/bin/python';
+            const content = `content\n${PROFILE_TAG_START}\n  ${expectedPath}  \n${PROFILE_TAG_END}\nmore content`;
+            const result = extractProfilePath(content);
+            assert.strictEqual(result, expectedPath);
+        });
+
+        test('should handle Windows-style line endings', () => {
+            const expectedPath = 'C:\\Python\\python.exe';
+            const content = `content\r\n${PROFILE_TAG_START}\r\n${expectedPath}\r\n${PROFILE_TAG_END}\r\nmore content`;
+            const result = extractProfilePath(content);
+            assert.strictEqual(result, expectedPath);
+        });
+
+        test('should extract path with special characters', () => {
+            const expectedPath = '/path with spaces/and (parentheses)/python';
+            const content = `${PROFILE_TAG_START}\n${expectedPath}\n${PROFILE_TAG_END}`;
+            const result = extractProfilePath(content);
+            assert.strictEqual(result, expectedPath);
+        });
+
+        test('should extract multiline content correctly', () => {
+            const expectedPath = 'line1\nline2\nline3';
+            const content = `${PROFILE_TAG_START}\n${expectedPath}\n${PROFILE_TAG_END}`;
+            const result = extractProfilePath(content);
+            assert.strictEqual(result, expectedPath);
+        });
+    });
+});