no config debugging: Allow concurrent debug sessions

Closes #613 and driveby fix of #820.
AI generated and untested but I've reviewed and the diff looks sensible to me (though it does seem to do a lot of mocking in tests).

Author: Zentrik

bundled/scripts/noConfigScripts/debugpy

@@ -1,4 +1,6 @@
 #! /bin/bash
 # Bash script
-export DEBUGPY_ADAPTER_ENDPOINTS=$VSCODE_DEBUGPY_ADAPTER_ENDPOINTS
-python3 $BUNDLED_DEBUGPY_PATH --listen 0 --wait-for-client $@
+endpoint_dir="$VSCODE_DEBUGPY_ADAPTER_ENDPOINTS"
+endpoint_file="$(mktemp -p "$endpoint_dir" endpoint-XXXXXX.txt)"
+export DEBUGPY_ADAPTER_ENDPOINTS="$endpoint_file"
+python3 "$BUNDLED_DEBUGPY_PATH" --listen 0 --wait-for-client "$@"

bundled/scripts/noConfigScripts/debugpy.bat

@@ -1,4 +1,4 @@
 @echo off
 :: Bat script
-set DEBUGPY_ADAPTER_ENDPOINTS=%VSCODE_DEBUGPY_ADAPTER_ENDPOINTS%
+set "DEBUGPY_ADAPTER_ENDPOINTS=%VSCODE_DEBUGPY_ADAPTER_ENDPOINTS%\endpoint-%RANDOM%%RANDOM%.txt"
 python %BUNDLED_DEBUGPY_PATH% --listen 0 --wait-for-client %*

bundled/scripts/noConfigScripts/debugpy.fish

@@ -1,3 +1,5 @@
 # Fish script
-set -x DEBUGPY_ADAPTER_ENDPOINTS $VSCODE_DEBUGPY_ADAPTER_ENDPOINTS
+set endpoint_dir $VSCODE_DEBUGPY_ADAPTER_ENDPOINTS
+set endpoint_file (mktemp -p $endpoint_dir endpoint-XXXXXX.txt)
+set -x DEBUGPY_ADAPTER_ENDPOINTS $endpoint_file
 python3 $BUNDLED_DEBUGPY_PATH --listen 0 --wait-for-client $argv

bundled/scripts/noConfigScripts/debugpy.ps1

@@ -1,5 +1,8 @@
 # PowerShell script
-$env:DEBUGPY_ADAPTER_ENDPOINTS = $env:VSCODE_DEBUGPY_ADAPTER_ENDPOINTS
+$endpointFolder = $env:VSCODE_DEBUGPY_ADAPTER_ENDPOINTS
+$endpointFile = Join-Path $endpointFolder ("endpoint-{0}.txt" -f ([System.Guid]::NewGuid().ToString('N').Substring(0, 8)))
+$env:DEBUGPY_ADAPTER_ENDPOINTS = $endpointFile
+
 $os = [System.Environment]::OSVersion.Platform
 if ($os -eq [System.PlatformID]::Win32NT) {
     python $env:BUNDLED_DEBUGPY_PATH --listen 0 --wait-for-client $args

src/extension/noConfigDebugInit.ts

@@ -8,6 +8,7 @@ import {
     DebugSessionOptions,
     Disposable,
     GlobalEnvironmentVariableCollection,
+    env,
     l10n,
     RelativePattern,
     workspace,
@@ -39,7 +40,7 @@ export async function registerNoConfigDebug(
     const collection = envVarCollection;
 
     // create a temp directory for the noConfigDebugAdapterEndpoints
-    // file path format: extPath/.noConfigDebugAdapterEndpoints/endpoint-stableWorkspaceHash.txt
+    // folder path format: extPath/.noConfigDebugAdapterEndpoints/<stableWorkspaceHash>
     let workspaceString = workspace.workspaceFile?.fsPath;
     if (!workspaceString) {
         workspaceString = workspace.workspaceFolders?.map((e) => e.uri.fsPath).join(';');
@@ -49,21 +50,26 @@ export async function registerNoConfigDebug(
         return Promise.resolve(new Disposable(() => {}));
     }
 
-    // create a stable hash for the workspace folder, reduce terminal variable churn
+    // create a stable hash for the workspace folder and VS Code window, reduce terminal variable churn
     const hash = crypto.createHash('sha256');
     hash.update(workspaceString.toString());
+    hash.update(env.sessionId);
     const stableWorkspaceHash = hash.digest('hex').slice(0, 16);
 
     const tempDirPath = path.join(extPath, '.noConfigDebugAdapterEndpoints');
-    const tempFilePath = path.join(tempDirPath, `endpoint-${stableWorkspaceHash}.txt`);
+    const endpointFolderPath = path.join(tempDirPath, stableWorkspaceHash);
 
     // create the temp directory if it doesn't exist
-    if (!fs.existsSync(tempDirPath)) {
-        fs.mkdirSync(tempDirPath, { recursive: true });
+    if (!fs.existsSync(endpointFolderPath)) {
+        fs.mkdirSync(endpointFolderPath, { recursive: true });
     } else {
-        // remove endpoint file in the temp directory if it exists
-        if (fs.existsSync(tempFilePath)) {
-            fs.unlinkSync(tempFilePath);
+        // clean out any existing endpoint files in the folder
+        const entries = fs.readdirSync(endpointFolderPath, { withFileTypes: true });
+        for (const entry of entries) {
+            if (entry.isFile()) {
+                const entryPath = path.join(endpointFolderPath, entry.name.toString());
+                fs.unlinkSync(entryPath);
+            }
         }
     }
     // clear the env var collection to remove any existing env vars
@@ -73,7 +79,7 @@ export async function registerNoConfigDebug(
     collection.replace('PYDEVD_DISABLE_FILE_VALIDATION', '1');
 
     // Add env vars for VSCODE_DEBUGPY_ADAPTER_ENDPOINTS, BUNDLED_DEBUGPY_PATH, and PATH
-    collection.replace('VSCODE_DEBUGPY_ADAPTER_ENDPOINTS', tempFilePath);
+    collection.replace('VSCODE_DEBUGPY_ADAPTER_ENDPOINTS', endpointFolderPath);
 
     const noConfigScriptsDir = path.join(extPath, 'bundled', 'scripts', 'noConfigScripts');
     const pathSeparator = process.platform === 'win32' ? ';' : ':';
@@ -93,7 +99,7 @@ export async function registerNoConfigDebug(
     );
 
     // create file system watcher for the debuggerAdapterEndpointFolder for when the communication port is written
-    const fileSystemWatcher = createFileSystemWatcher(new RelativePattern(tempDirPath, '**/*.txt'));
+    const fileSystemWatcher = createFileSystemWatcher(new RelativePattern(endpointFolderPath, '**/*.txt'));
     const fileCreationEvent = fileSystemWatcher.onDidCreate(async (uri) => {
         sendTelemetryEvent(EventName.DEBUG_SESSION_START, undefined, {
             trigger: 'noConfig' as TriggerType,

src/test/unittest/noConfigDebugInit.unit.test.ts

@@ -6,7 +6,7 @@ import { IExtensionContext } from '../../extension/common/types';
 import { registerNoConfigDebug as registerNoConfigDebug } from '../../extension/noConfigDebugInit';
 import * as TypeMoq from 'typemoq';
 import * as sinon from 'sinon';
-import { DebugConfiguration, DebugSessionOptions, RelativePattern, Uri, workspace } from 'vscode';
+import { DebugConfiguration, DebugSessionOptions, RelativePattern, Uri, env, workspace } from 'vscode';
 import * as utils from '../../extension/utils';
 import { assert } from 'console';
 import * as fs from 'fs';
@@ -22,6 +22,9 @@ suite('setup for no-config debug scenario', function () {
     let DEBUGPY_ADAPTER_ENDPOINTS = 'DEBUGPY_ADAPTER_ENDPOINTS';
     let BUNDLED_DEBUGPY_PATH = 'BUNDLED_DEBUGPY_PATH';
     let workspaceUriStub: sinon.SinonStub;
+    let sessionIdStub: sinon.SinonStub;
+    let stableWorkspaceHash: string;
+    let workspacePath: string;
 
     const testDataDir = path.join(__dirname, 'testData');
     const testFilePath = path.join(testDataDir, 'debuggerAdapterEndpoint.txt');
@@ -34,19 +37,28 @@ suite('setup for no-config debug scenario', function () {
             noConfigScriptsDir = path.join(context.object.extensionPath, 'bundled/scripts/noConfigScripts');
             bundledDebugPath = path.join(context.object.extensionPath, 'bundled/libs/debugpy');
 
+            sessionIdStub = sinon.stub(env, 'sessionId').value('test-session');
+            workspacePath = os.tmpdir();
+
             // Stub crypto.randomBytes with proper typing
             let randomBytesStub = sinon.stub(crypto, 'randomBytes');
             // Provide a valid Buffer object
             randomBytesStub.callsFake((_size: number) => Buffer.from('1234567899', 'hex'));
 
-            workspaceUriStub = sinon.stub(workspace, 'workspaceFolders').value([{ uri: Uri.parse(os.tmpdir()) }]);
+            workspaceUriStub = sinon.stub(workspace, 'workspaceFolders').value([{ uri: Uri.parse(workspacePath) }]);
+
+            const hash = crypto.createHash('sha256');
+            hash.update(workspacePath.toString());
+            hash.update('test-session');
+            stableWorkspaceHash = hash.digest('hex').slice(0, 16);
         } catch (error) {
             console.error('Error in setup:', error);
         }
     });
     teardown(() => {
         sinon.restore();
         workspaceUriStub.restore();
+        sessionIdStub.restore();
     });
 
     test('should add environment variables for DEBUGPY_ADAPTER_ENDPOINTS, BUNDLED_DEBUGPY_PATH, and PATH', async () => {
@@ -59,7 +71,10 @@ suite('setup for no-config debug scenario', function () {
             .setup((x) => x.replace(TypeMoq.It.isAny(), TypeMoq.It.isAny()))
             .callback((key, value) => {
                 if (key === DEBUGPY_ADAPTER_ENDPOINTS) {
-                    assert(value.includes('endpoint-'));
+                    assert(
+                        value ===
+                            path.join(context.object.extensionPath, '.noConfigDebugAdapterEndpoints', stableWorkspaceHash),
+                    );
                 } else if (key === BUNDLED_DEBUGPY_PATH) {
                     assert(value === bundledDebugPath);
                 } else if (key === 'PYDEVD_DISABLE_FILE_VALIDATION') {
@@ -194,7 +209,7 @@ suite('setup for no-config debug scenario', function () {
         // Assert
         sinon.assert.calledOnce(createFileSystemWatcherFunct);
         const expectedPattern = new RelativePattern(
-            path.join(os.tmpdir(), '.noConfigDebugAdapterEndpoints'),
+            path.join(os.tmpdir(), '.noConfigDebugAdapterEndpoints', stableWorkspaceHash),
             '**/*.txt',
         );
         sinon.assert.calledWith(createFileSystemWatcherFunct, expectedPattern);
@@ -261,26 +276,33 @@ suite('setup for no-config debug scenario', function () {
         sinon.assert.calledWith(debugStub, undefined, expectedConfig, optionsExpected);
     });
 
-    test('should check if tempFilePath exists when debuggerAdapterEndpointFolder exists', async () => {
+    test('should clear existing endpoint files when debuggerAdapterEndpointFolder exists', async () => {
         // Arrange
         const environmentVariableCollectionMock = TypeMoq.Mock.ofType<any>();
         context.setup((c) => c.environmentVariableCollection).returns(() => environmentVariableCollectionMock.object);
 
-        const fsExistsSyncStub = sinon.stub(fs, 'existsSync').returns(true);
+        const endpointFolderPath = path.join(os.tmpdir(), '.noConfigDebugAdapterEndpoints', stableWorkspaceHash);
+        const fsExistsSyncStub = sinon.stub(fs, 'existsSync').callsFake((p) => p === endpointFolderPath);
+        const fakeDirent = { isFile: () => true, name: Buffer.from('old.txt') } as unknown as fs.Dirent<Buffer>;
+        const fsReaddirSyncStub = sinon
+            .stub(fs, 'readdirSync')
+            .callsFake((dirPath: fs.PathLike, options?: any) => {
+                assert(dirPath === endpointFolderPath);
+                assert(options?.withFileTypes === true);
+                return [fakeDirent] as unknown as fs.Dirent<Buffer>[];
+            });
         const fsUnlinkSyncStub = sinon.stub(fs, 'unlinkSync');
 
         // Act
         await registerNoConfigDebug(context.object.environmentVariableCollection, context.object.extensionPath);
 
         // Assert
-        sinon.assert.calledWith(
-            fsExistsSyncStub,
-            sinon.match((value: any) => value.includes('endpoint-')),
-        );
-        sinon.assert.calledOnce(fsUnlinkSyncStub);
+        sinon.assert.calledWith(fsExistsSyncStub, endpointFolderPath);
+        sinon.assert.calledWith(fsUnlinkSyncStub, path.join(endpointFolderPath, 'old.txt'));
 
         // Cleanup
         fsExistsSyncStub.restore();
+        fsReaddirSyncStub.restore();
         fsUnlinkSyncStub.restore();
     });
 });