fix: add bash command parsing for telemetry metrics (aws#2039)

* fix: add bash command parsing for telemetry metrics

* fix: handle metric withint executeBash tool itself

Author: chungjac

server/aws-lsp-codewhisperer/src/language-server/agenticChat/tools/executeBash.ts

@@ -12,6 +12,8 @@ import { Features } from '../../types'
 import { getWorkspaceFolderPaths } from '@aws/lsp-core/out/util/workspaceUtils'
 // eslint-disable-next-line import/no-nodejs-modules
 import { existsSync, statSync } from 'fs'
+import { parseBaseCommands } from '../utils/commandParser'
+import { BashCommandEvent, ChatTelemetryEventName } from '../../../shared/telemetry/types'
 
 export enum CommandCategory {
     ReadOnly,
@@ -130,9 +132,15 @@ export class ExecuteBash {
     private childProcess?: ChildProcess
     private readonly logging: Features['logging']
     private readonly workspace: Features['workspace']
-    constructor(features: Pick<Features, 'logging' | 'workspace'> & Partial<Features>) {
+    private readonly telemetry: Features['telemetry']
+    private readonly credentialsProvider: Features['credentialsProvider']
+    constructor(
+        features: Pick<Features, 'logging' | 'workspace' | 'telemetry' | 'credentialsProvider'> & Partial<Features>
+    ) {
         this.logging = features.logging
         this.workspace = features.workspace
+        this.telemetry = features.telemetry
+        this.credentialsProvider = features.credentialsProvider
     }
 
     public async validate(input: ExecuteBashParams): Promise<void> {
@@ -567,6 +575,7 @@ export class ExecuteBash {
                 })
             }
 
+            let success = false
             try {
                 const result = await this.childProcess.run()
 
@@ -579,7 +588,7 @@ export class ExecuteBash {
                 const exitStatus = result.exitCode ?? 0
                 const stdout = stdoutBuffer.join('\n')
                 const stderr = stderrBuffer.join('\n')
-                const success = exitStatus === 0 && !stderr
+                success = exitStatus === 0 && !stderr
                 const [stdoutTrunc, stdoutSuffix] = ExecuteBash.truncateSafelyWithSuffix(
                     stdout,
                     maxToolResponseSize / 3
@@ -611,6 +620,25 @@ export class ExecuteBash {
                     reject(new Error(`Failed to execute command: ${err.message}`))
                 }
             } finally {
+                // Extract individual base commands for telemetry purposes
+                const args = split(params.command)
+                const baseCommands = parseBaseCommands(args)
+                baseCommands.forEach(command => {
+                    const metricPayload = {
+                        name: ChatTelemetryEventName.BashCommand,
+                        data: {
+                            credentialStartUrl: this.credentialsProvider.getConnectionMetadata()?.sso?.startUrl,
+                            result: cancellationToken?.isCancellationRequested
+                                ? 'Cancelled'
+                                : success
+                                  ? 'Succeeded'
+                                  : 'Failed',
+                            command: command,
+                        } as BashCommandEvent,
+                    }
+                    this.telemetry.emitMetric(metricPayload)
+                })
+
                 await writer?.close()
                 writer?.releaseLock()
             }

server/aws-lsp-codewhisperer/src/language-server/agenticChat/tools/toolServer.ts

@@ -172,8 +172,8 @@ export const QCodeAnalysisServer: Server = ({
     return () => {}
 }
 
-export const BashToolsServer: Server = ({ logging, workspace, agent, lsp }) => {
-    const bashTool = new ExecuteBash({ logging, workspace, lsp })
+export const BashToolsServer: Server = ({ logging, workspace, agent, lsp, telemetry, credentialsProvider }) => {
+    const bashTool = new ExecuteBash({ logging, workspace, lsp, telemetry, credentialsProvider })
     agent.addTool(
         bashTool.getSpec(),
         async (input: ExecuteBashParams, token?: CancellationToken, updates?: WritableStream) => {

server/aws-lsp-codewhisperer/src/language-server/agenticChat/utils/commandParser.test.ts

@@ -0,0 +1,85 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import * as assert from 'assert'
+import { parseBaseCommands } from './commandParser'
+import { split } from 'shlex'
+
+describe('commandParser', () => {
+    describe('parseBaseCommands', () => {
+        it('should extract base command from a simple command', () => {
+            assert.deepStrictEqual(parseBaseCommands(split('cd /home/user/documents')), ['cd'])
+        })
+
+        it('should extract multiple commands separated by &&', () => {
+            assert.deepStrictEqual(parseBaseCommands(split('echo "Hello World" && ls -la')), ['echo', 'ls'])
+        })
+
+        it('should extract multiple commands separated by ||', () => {
+            assert.deepStrictEqual(parseBaseCommands(split('grep "pattern" file.txt || echo "Not found"')), [
+                'grep',
+                'echo',
+            ])
+        })
+
+        it('should extract multiple commands separated by |', () => {
+            assert.deepStrictEqual(parseBaseCommands(split('cat file.txt | grep "pattern"')), ['cat', 'grep'])
+        })
+
+        it('should handle commands with quotes', () => {
+            assert.deepStrictEqual(
+                parseBaseCommands(split('echo "text with spaces" && grep "pattern with spaces" file.txt')),
+                ['echo', 'grep']
+            )
+        })
+
+        it('should return empty array for null, undefined, empty input', () => {
+            assert.deepStrictEqual(parseBaseCommands(null as any), [])
+            assert.deepStrictEqual(parseBaseCommands(undefined as any), [])
+            assert.deepStrictEqual(parseBaseCommands(split('')), [])
+        })
+
+        it('should handle commands with semicolons', () => {
+            assert.deepStrictEqual(parseBaseCommands(split('cd /tmp; ls -la; echo "done"')), ['cd', 'ls', 'echo'])
+        })
+
+        it('should handle commands with sudo prefix', () => {
+            assert.deepStrictEqual(parseBaseCommands(split('sudo apt-get install package')), ['sudo', 'apt-get'])
+            assert.deepStrictEqual(parseBaseCommands(split('sudo -u user command')), ['sudo', 'command'])
+        })
+
+        it('should handle commands with time prefix', () => {
+            assert.deepStrictEqual(parseBaseCommands(split('time curl http://example.com')), ['time', 'curl'])
+        })
+
+        it('should handle commands with path prefixes', () => {
+            assert.deepStrictEqual(parseBaseCommands(split('/usr/bin/python script.py')), ['python'])
+            assert.deepStrictEqual(parseBaseCommands(split('./script.sh -arg')), ['script.sh'])
+            assert.deepStrictEqual(parseBaseCommands(split('../bin/tool --option')), ['tool'])
+        })
+
+        it('should handle commands with sudo and path prefixes', () => {
+            assert.deepStrictEqual(parseBaseCommands(split('sudo /usr/bin/apt-get update')), ['sudo', 'apt-get'])
+        })
+
+        it('should handle multiple commands with mixed separators', () => {
+            assert.deepStrictEqual(parseBaseCommands(split('cd /tmp; ls -la | grep "file" && echo "found"')), [
+                'cd',
+                'ls',
+                'grep',
+                'echo',
+            ])
+        })
+
+        it('should handle commands with other common prefixes', () => {
+            assert.deepStrictEqual(parseBaseCommands(split('nice -n 10 command')), ['nice', 'command'])
+            assert.deepStrictEqual(parseBaseCommands(split('nohup command &')), ['nohup', 'command'])
+        })
+
+        it('should handle commands with function calls', () => {
+            assert.deepStrictEqual(parseBaseCommands(split('function_name args')), ['function_name'])
+        })
+    })
+})

server/aws-lsp-codewhisperer/src/language-server/agenticChat/utils/commandParser.ts

@@ -0,0 +1,98 @@
+import { splitOperators } from '../tools/executeBash'
+
+/**
+ * Parses command arguments and extracts only the base commands without arguments or options.
+ *
+ * Examples:
+ * - "cd /home/user/documents" -> ["cd"]
+ * - "echo 'Hello World' && ls -la" -> ["echo", "ls"]
+ * - "sudo apt-get install" -> ["sudo", "apt-get"]
+ * - "time curl http://example.com" -> ["time", "curl"]
+ * - "command1; command2" -> ["command1", "command2"]
+ * - "/usr/bin/python script.py" -> ["python"]
+ * - "./script.sh" -> ["script.sh"]
+ * - "function_name args" -> ["function_name"]
+ *
+ * @param args Array of command arguments
+ * @returns Array of base commands found in the input args
+ */
+export function parseBaseCommands(args: string[]): string[] {
+    if (!args || !Array.isArray(args) || args.length === 0) {
+        return []
+    }
+
+    const baseCommands: string[] = []
+
+    // Process the args to extract base commands
+    let i = 0
+    let expectCommand = true // Flag to indicate we're expecting a command
+
+    while (i < args.length) {
+        const arg = args[i]
+
+        // Check if this arg is an operator or contains an operator
+        if (splitOperators.has(arg) || arg.includes(';')) {
+            expectCommand = true // Next argument should be a command
+            i++
+            continue
+        }
+
+        if (expectCommand) {
+            // Extract the base command
+            let baseCommand = arg
+
+            // Handle path prefixes (/usr/bin/command or ./command)
+            if (baseCommand.includes('/')) {
+                baseCommand = baseCommand.split('/').pop() || baseCommand
+            }
+
+            baseCommands.push(baseCommand)
+
+            // Special case for sudo, time, etc. - include the actual command too
+            if (['sudo', 'time', 'nice', 'nohup', 'env'].includes(baseCommand)) {
+                // Skip any flags/options and their values
+                let j = i + 1
+                while (j < args.length) {
+                    // If we find an operator, stop looking for the command
+                    if (splitOperators.has(args[j]) || args[j].includes(';')) {
+                        break
+                    }
+
+                    // Skip flag and its value if present
+                    if (args[j].startsWith('-')) {
+                        // Handle flags with values (e.g., -u user, -n 10)
+                        if (
+                            j + 1 < args.length &&
+                            !args[j + 1].startsWith('-') &&
+                            !splitOperators.has(args[j + 1]) &&
+                            !args[j + 1].includes(';')
+                        ) {
+                            j += 2 // Skip both the flag and its value
+                        } else {
+                            j++ // Skip just the flag
+                        }
+                        continue
+                    }
+
+                    // Found the actual command
+                    let nextCommand = args[j]
+
+                    // Handle path prefixes for the command after sudo/time
+                    if (nextCommand.includes('/')) {
+                        nextCommand = nextCommand.split('/').pop() || nextCommand
+                    }
+
+                    baseCommands.push(nextCommand)
+                    break
+                }
+            }
+
+            // For all commands, we don't expect another command until we see an operator
+            expectCommand = false
+        }
+
+        i++
+    }
+
+    return baseCommands
+}

server/aws-lsp-codewhisperer/src/shared/telemetry/types.ts

@@ -210,6 +210,7 @@ export enum ChatTelemetryEventName {
     ExportTab = 'amazonq_exportTab',
     UiClick = 'ui_click',
     ActiveUser = 'amazonq_activeUser',
+    BashCommand = 'amazonq_bashCommand',
 }
 
 export interface ChatTelemetryEventMap {
@@ -234,6 +235,7 @@ export interface ChatTelemetryEventMap {
     [ChatTelemetryEventName.ExportTab]: ExportTabEvent
     [ChatTelemetryEventName.UiClick]: UiClickEvent
     [ChatTelemetryEventName.ActiveUser]: ActiveUserEvent
+    [ChatTelemetryEventName.BashCommand]: BashCommandEvent
 }
 
 export type AgencticLoop_InvokeLLMEvent = {
@@ -271,6 +273,12 @@ export type ActiveUserEvent = {
     result: string
 }
 
+export type BashCommandEvent = {
+    credentialStartUrl: string
+    result: string
+    command: string
+}
+
 export type ModifyCodeEvent = {
     cwsprChatConversationId: string
     cwsprChatMessageId: string