Add ideClient tag via bazel params

Author: shuklahy

.gitignore

@@ -6,3 +6,4 @@ dist
 .DS_Store
 .bazelbsp
 .bsp
+vscode-bazel-bsp-*.vsix

src/test-info/test-info.ts

@@ -124,6 +124,16 @@ export class BuildTargetTestCaseInfo extends TestCaseInfo {
       }
     }
 
+    // Add the IDE tag (--define flag) to additionalBazelParams
+    const ideTag = currentRun.getIdeTag()
+    if (ideTag && ideTag.trim().length > 0) {
+      if (bazelParams.additionalBazelParams) {
+        bazelParams.additionalBazelParams += ` ${ideTag}`
+      } else {
+        bazelParams.additionalBazelParams = ideTag
+      }
+    }
+
     const params = {
       targets: [this.target.id],
       originId: currentRun.originName,

src/test-runner/run-factory.ts

@@ -7,6 +7,7 @@ import {TestRunTracker} from './run-tracker'
 import {BazelBSPBuildClient} from '../test-explorer/client'
 import {CoverageTracker} from '../coverage-utils/coverage-tracker'
 import {LanguageToolManager} from '../language-tools/manager'
+import {detectIdeClient} from '../utils/utils'
 
 @Injectable()
 export class RunTrackerFactory {
@@ -37,6 +38,9 @@ export class RunTrackerFactory {
       languageToolManager: this.languageToolManager,
     })
 
+    const ideClient = detectIdeClient()
+    requestTracker.setIdeTag(ideClient)
+
     this.buildClient.registerOriginHandlers(originId, requestTracker)
     requestTracker.onDone(() =>
       this.buildClient.disposeOriginHandlers(originId)

src/test-runner/run-tracker.ts

@@ -72,6 +72,7 @@ export class TestRunTracker implements TaskOriginHandlers {
   private buildTaskTracker: TaskEventTracker = new TaskEventTracker()
   private debugInfo: DebugInfo | undefined
   private hasDebugSessionBeenInitiated = false
+  private ideTag: string
 
   constructor(params: RunTrackerParams) {
     this.allTests = new Map<TestItemType, TestCaseInfo[]>()
@@ -83,6 +84,7 @@ export class TestRunTracker implements TaskOriginHandlers {
     this.cancelToken = params.cancelToken
     this.coverageTracker = params.coverageTracker
     this.languageToolManager = params.languageToolManager
+    this.ideTag = 'unknown'
 
     this.prepareCurrentRun()
     this.prepareDebugInfo()
@@ -491,6 +493,23 @@ export class TestRunTracker implements TaskOriginHandlers {
         )
     }
   }
+
+  /**
+   * Set the IDE tag to be used for this test run
+   * @param ideClient IDE client identifier (e.g., 'vscode', 'cursor')
+   */
+  public setIdeTag(ideClient: string): void {
+    // Use Bazel's --define flag which is specifically designed for user-defined values
+    this.ideTag = `--define=ide_client=${ideClient}`
+  }
+
+  /**
+   * Get the IDE tag for this test run
+   * @returns The IDE client identifier
+   */
+  public getIdeTag(): string {
+    return this.ideTag
+  }
 }
 
 function formatTestResultMessage(

src/test/suite/run-factory.test.ts

@@ -22,6 +22,7 @@ import {TestItemFactory} from '../../test-info/test-item-factory'
 import {CoverageTracker} from '../../coverage-utils/coverage-tracker'
 import {LanguageToolManager} from '../../language-tools/manager'
 import {SyncHintDecorationsManager} from '../../test-explorer/decorator'
+import * as utils from '../../utils/utils'
 
 suite('Test Runner Factory', () => {
   let ctx: vscode.ExtensionContext
@@ -117,4 +118,25 @@ suite('Test Runner Factory', () => {
     assert.equal(registerHandlersStub.firstCall.args[1], runTracker)
     assert.ok(disposeHandlersStub.calledOnce)
   })
+
+  test('newRun sets IDE tag', async () => {
+    const detectIdeClientStub = sandbox.stub(utils, 'detectIdeClient')
+    detectIdeClientStub.returns('test-ide')
+
+    try {
+      const roots: vscode.TestItem[] = []
+      testCaseStore.testController.items.forEach(item => {
+        roots.push(item)
+      })
+      const sampleToken = new vscode.CancellationTokenSource().token
+      const runTracker = runFactory.newRun(
+        new vscode.TestRunRequest(Array.from(roots)),
+        sampleToken
+      )
+      assert.ok(detectIdeClientStub.calledOnce)
+      assert.equal(runTracker.getIdeTag(), '--define=ide_client=test-ide')
+    } finally {
+      detectIdeClientStub.restore()
+    }
+  })
 })

src/test/suite/runner.test.ts

@@ -31,6 +31,7 @@ import {CoverageTracker} from '../../coverage-utils/coverage-tracker'
 import {LanguageToolManager} from '../../language-tools/manager'
 import {SyncHintDecorationsManager} from '../../test-explorer/decorator'
 import * as settings from '../../utils/settings'
+import * as utils from '../../utils/utils'
 
 suite('Test Runner', () => {
   let ctx: vscode.ExtensionContext
@@ -207,6 +208,9 @@ suite('Test Runner', () => {
       .stub(sampleConn, 'sendRequest')
       .returns(Promise.resolve(sampleResult))
 
+    // Mock the IDE tag detection
+    sandbox.stub(utils, 'detectIdeClient').returns('cursor')
+
     // Ensure run profile creation.
     await testRunner.onModuleInit()
     const runProfile = testRunner.runProfiles.get(
@@ -234,7 +238,7 @@ suite('Test Runner', () => {
       assert.ok(!callArgs[1].data.coverage)
       assert.strictEqual(
         callArgs[1].data.additionalBazelParams,
-        '--my_flag_1 --my_flag_2'
+        '--my_flag_1 --my_flag_2 --define=ide_client=cursor'
       )
       assert.strictEqual(callArgs[1].dataKind, TestParamsDataKind.BazelTest)
     }

src/test/suite/test-info.test.ts

@@ -198,6 +198,67 @@ suite('TestInfo', () => {
       const result = testInfo.prepareTestRunParams(currentRun)
       assert.equal(result, undefined)
     })
+
+    test('build target with IDE tag', async () => {
+      const testItem = testController.createTestItem('sample', 'sample')
+      const testInfo = new BuildTargetTestCaseInfo(testItem, sampleTarget)
+
+      // Test with IDE tag
+      const currentRun = sandbox.createStubInstance(TestRunTracker)
+      sandbox.stub(currentRun, 'originName').get(() => 'sample')
+      currentRun.getRunProfileKind.returns(vscode.TestRunProfileKind.Run)
+      currentRun.getIdeTag.returns('--define=ide_client=cursor')
+
+      const result = testInfo.prepareTestRunParams(currentRun)
+      assert.deepStrictEqual(result, {
+        arguments: [],
+        environmentVariables: {},
+        originId: 'sample',
+        targets: [
+          {
+            uri: '//sample/target:test',
+          },
+        ],
+        workingDirectory: '',
+        dataKind: TestParamsDataKind.BazelTest,
+        data: {
+          coverage: false,
+          additionalBazelParams: '--define=ide_client=cursor',
+        },
+      })
+    })
+
+    test('build target with IDE tag and debug flags', async () => {
+      const testItem = testController.createTestItem('sample', 'sample')
+      const testInfo = new BuildTargetTestCaseInfo(testItem, sampleTarget)
+
+      // Test with IDE tag and debug flags
+      const currentRunWithDebug = sandbox.createStubInstance(TestRunTracker)
+      sandbox.stub(currentRunWithDebug, 'originName').get(() => 'sample')
+      currentRunWithDebug.getRunProfileKind.returns(
+        vscode.TestRunProfileKind.Debug
+      )
+      currentRunWithDebug.getIdeTag.returns('--define=ide_client=vscode')
+      currentRunWithDebug.getDebugBazelFlags.returns(['--flag1', '--flag2'])
+
+      const resultWithDebug = testInfo.prepareTestRunParams(currentRunWithDebug)
+      assert.deepStrictEqual(resultWithDebug, {
+        arguments: [],
+        environmentVariables: {},
+        originId: 'sample',
+        targets: [
+          {
+            uri: '//sample/target:test',
+          },
+        ],
+        workingDirectory: '',
+        dataKind: TestParamsDataKind.BazelTest,
+        data: {
+          coverage: false,
+          additionalBazelParams: '--flag1 --flag2 --define=ide_client=vscode',
+        },
+      })
+    })
   })
 
   suite('Set display name', () => {

src/test/suite/utils.test.ts

@@ -4,7 +4,7 @@ import sinon from 'sinon'
 import {afterEach} from 'mocha'
 import * as zlib from 'zlib'
 
-import {Deferred, Utils} from '../../utils/utils'
+import {Deferred, Utils, detectIdeClient} from '../../utils/utils'
 
 suite('Utils Test Suite', () => {
   const sandbox = sinon.createSandbox()
@@ -119,6 +119,71 @@ suite('Utils Test Suite', () => {
       assert.ok(error instanceof Error)
     }
   })
+
+  test('detectIdeClient with different environments', async () => {
+    const processEnv = process.env
+
+    const testCases = [
+      {
+        env: {
+          PATH: '/usr/bin:/bin:/usr/sbin:/sbin:/usr/local/bin:/path/to/.vscode/remote-cli',
+          __CFBundleIdentifier: '',
+        },
+        expected: 'vscode',
+        name: 'VSCode remote',
+      },
+      {
+        env: {
+          PATH: '/usr/bin:/bin:/usr/sbin:/sbin:/usr/local/bin',
+          __CFBundleIdentifier: 'com.microsoft.VSCode',
+        },
+        expected: 'vscode',
+        name: 'VSCode local',
+      },
+      {
+        env: {
+          PATH: '/usr/bin:/bin:/usr/sbin:/sbin:/usr/local/bin:/path/to/.cursor/remote-cli',
+          __CFBundleIdentifier: '',
+        },
+        expected: 'cursor',
+        name: 'Cursor remote',
+      },
+      {
+        env: {
+          PATH: '/usr/bin:/bin:/usr/sbin:/sbin:/usr/local/bin',
+          __CFBundleIdentifier: 'com.todesktop.230313mzl4w4u92',
+        },
+        expected: 'cursor',
+        name: 'Cursor local',
+      },
+      {
+        env: {
+          PATH: '/usr/bin:/bin:/usr/sbin:/sbin:/usr/local/bin',
+          __CFBundleIdentifier: 'com.microsoft.VSCodeInsiders',
+        },
+        expected: 'vscode-insiders',
+        name: 'VSCode Insiders local',
+      },
+      {
+        env: {
+          PATH: '/usr/bin:/bin:/usr/sbin:/sbin:/usr/local/bin',
+          __CFBundleIdentifier: '',
+        },
+        expected: 'unknown',
+        name: 'Unknown IDE',
+      },
+    ]
+
+    try {
+      for (const {env, expected, name} of testCases) {
+        process.env = env
+        const result = detectIdeClient()
+        assert.strictEqual(result, expected, `Failed: ${name}`)
+      }
+    } finally {
+      process.env = processEnv
+    }
+  })
 })
 
 suite('Deferred Promise Test Suite', () => {

src/utils/utils.ts

@@ -104,3 +104,35 @@ export class Deferred<T> {
     })
   }
 }
+
+/**
+ * Detect which IDE client is being used.
+ * @returns {string} The detected IDE client identifier
+ */
+export function detectIdeClient(): string {
+  const path = process.env.PATH || ''
+  const cfBundleId = process.env.__CFBundleIdentifier || ''
+
+  // Cursor detection
+  if (
+    (path.includes('.cursor') && path.includes('remote-cli')) ||
+    cfBundleId === 'com.todesktop.230313mzl4w4u92'
+  ) {
+    return 'cursor'
+  }
+
+  // VS Code detection
+  if (
+    (path.includes('.vscode') && path.includes('remote-cli')) ||
+    cfBundleId === 'com.microsoft.VSCode'
+  ) {
+    return 'vscode'
+  }
+
+  // VS Code Insiders detection
+  if (cfBundleId === 'com.microsoft.VSCodeInsiders') {
+    return 'vscode-insiders'
+  }
+
+  return 'unknown'
+}