Adding Tool execution

Executing default commands in the terminal

Temporary moving the command execution logic to messenger.ts, need to implement this in controller.ts

Disabling the Run command button

Agentic IDE Terminal integration and show the logs in the terminal

Agentic IDE Terminal integration

Author: laileni-aws

packages/core/src/amazonq/webview/ui/apps/cwChatConnector.ts

@@ -3,7 +3,14 @@
  * SPDX-License-Identifier: Apache-2.0
  */
 
-import { ChatItemButton, ChatItemFormItem, ChatItemType, MynahUIDataModel, QuickActionCommand } from '@aws/mynah-ui'
+import {
+    ChatItem,
+    ChatItemButton,
+    ChatItemFormItem,
+    ChatItemType,
+    MynahUIDataModel,
+    QuickActionCommand,
+} from '@aws/mynah-ui'
 import { TabType } from '../storages/tabsStorage'
 import { CWCChatItem } from '../connector'
 import { BaseConnector, BaseConnectorProps } from './baseConnector'
@@ -18,12 +25,14 @@ export interface ConnectorProps extends BaseConnectorProps {
         title?: string,
         description?: string
     ) => void
+    onChatAnswerUpdated?: (tabID: string, message: ChatItem) => void
 }
 
 export class Connector extends BaseConnector {
     private readonly onCWCContextCommandMessage
     private readonly onContextCommandDataReceived
     private readonly onShowCustomForm
+    private readonly onChatAnswerUpdated
 
     override getTabType(): TabType {
         return 'cwc'
@@ -34,6 +43,7 @@ export class Connector extends BaseConnector {
         this.onCWCContextCommandMessage = props.onCWCContextCommandMessage
         this.onContextCommandDataReceived = props.onContextCommandDataReceived
         this.onShowCustomForm = props.onShowCustomForm
+        this.onChatAnswerUpdated = props.onChatAnswerUpdated
     }
 
     onSourceLinkClick = (tabID: string, messageId: string, link: string): void => {
@@ -96,6 +106,7 @@ export class Connector extends BaseConnector {
                 userIntent: messageData.userIntent,
                 codeBlockLanguage: messageData.codeBlockLanguage,
                 contextList: messageData.contextList,
+                buttons: messageData.buttons ?? undefined,
             }
 
             // If it is not there we will not set it
@@ -137,6 +148,7 @@ export class Connector extends BaseConnector {
                               options: messageData.followUps,
                           }
                         : undefined,
+                buttons: messageData.buttons ?? undefined,
             }
             this.onChatAnswerReceived(messageData.tabID, answer, messageData)
 
@@ -204,7 +216,7 @@ export class Connector extends BaseConnector {
         }
 
         if (messageData.type === 'customFormActionMessage') {
-            this.onCustomFormAction(messageData.tabID, messageData.action)
+            this.onCustomFormAction(messageData.tabID, messageData.messageId, messageData.action)
             return
         }
         // For other message types, call the base class handleMessageReceive
@@ -235,6 +247,7 @@ export class Connector extends BaseConnector {
 
     onCustomFormAction(
         tabId: string,
+        messageId: string,
         action: {
             id: string
             text?: string | undefined
@@ -248,9 +261,37 @@ export class Connector extends BaseConnector {
         this.sendMessageToExtension({
             command: 'form-action-click',
             action: action,
+            formSelectedValues: action.formItemValues,
             tabType: this.getTabType(),
             tabID: tabId,
         })
+
+        if (this.onChatAnswerUpdated === undefined) {
+            return
+        }
+        const answer: ChatItem = {
+            type: ChatItemType.ANSWER,
+            messageId: messageId,
+            buttons: [],
+        }
+
+        switch (action.id) {
+            case 'RunCommand':
+                answer.buttons = [
+                    {
+                        keepCardAfterClick: true,
+                        text: 'Executing Command',
+                        id: 'RunCommandClicked',
+                        status: 'success',
+                        position: 'outside',
+                        disabled: true,
+                    },
+                ]
+                break
+            default:
+                break
+        }
+        this.onChatAnswerUpdated(tabId, answer)
     }
 
     onFileClick = (tabID: string, filePath: string, messageId?: string) => {

packages/core/src/amazonq/webview/ui/connector.ts

@@ -711,7 +711,7 @@ export class Connector {
                         tabType: 'cwc',
                     })
                 } else {
-                    this.cwChatConnector.onCustomFormAction(tabId, action)
+                    this.cwChatConnector.onCustomFormAction(tabId, messageId ?? '', action)
                 }
                 break
             case 'agentWalkthrough': {

packages/core/src/amazonq/webview/ui/main.ts

@@ -352,6 +352,7 @@ export const createMynahUI = (
                     ...(item.followUp !== undefined ? { followUp: item.followUp } : {}),
                     ...(item.fileList !== undefined ? { fileList: item.fileList } : {}),
                     ...(item.header !== undefined ? { header: item.header } : { header: undefined }),
+                    ...(item.buttons !== undefined ? { buttons: item.buttons } : { buttons: undefined }),
                 })
                 if (
                     item.messageId !== undefined &&

packages/core/src/codewhispererChat/clients/chat/v0/chat.ts

@@ -18,6 +18,9 @@ export class ChatSession {
     // TODO: doesn't handle the edge case when two files share the same relativePath string but from different root
     // e.g. root_a/file1 vs root_b/file1
     relativePathToWorkspaceRoot: Map<string, string> = new Map()
+
+    public storedBashCommands: string[] = []
+
     public get sessionIdentifier(): string | undefined {
         return this.sessionId
     }

packages/core/src/codewhispererChat/controllers/chat/controller.ts

@@ -4,6 +4,9 @@
  */
 import * as path from 'path'
 import * as vscode from 'vscode'
+import * as os from 'os'
+import { fs } from '../../../shared/fs/fs'
+import { ChildProcess } from '../../../shared/utilities/processUtils'
 import { Event as VSCodeEvent, Uri, workspace, window, ViewColumn, Position, Selection } from 'vscode'
 import { EditorContextExtractor } from '../../editor/context/extractor'
 import { ChatSessionStorage } from '../../storages/chatSession'
@@ -68,7 +71,6 @@ import { MynahIconsType, MynahUIDataModel, QuickActionCommand } from '@aws/mynah
 import { LspClient } from '../../../amazonq/lsp/lspClient'
 import { AdditionalContextPrompt, ContextCommandItem, ContextCommandItemType } from '../../../amazonq/lsp/types'
 import { workspaceCommand } from '../../../amazonq/webview/ui/tabs/constants'
-import fs from '../../../shared/fs/fs'
 import { FeatureConfigProvider, Features } from '../../../shared/featureConfig'
 import { i18n } from '../../../shared/i18n-helper'
 import {
@@ -132,6 +134,8 @@ export interface ChatControllerMessageListeners {
 }
 
 export class ChatController {
+    // Store the last terminal output
+    private lastTerminalOutput: string = ''
     private readonly sessionStorage: ChatSessionStorage
     private readonly triggerEventsStorage: TriggerEventsStorage
     private readonly messenger: Messenger
@@ -560,20 +564,99 @@ export class ChatController {
     }
 
     private async processCustomFormAction(message: CustomFormActionMessage) {
-        if (message.action.id === 'submit-create-prompt') {
-            const userPromptsDirectory = getUserPromptsDirectory()
+        const session = this.sessionStorage.getSession(message.tabID ?? '')
+        if (!session) {
+            getLogger().error(`No session found for tab: ${message.tabID ?? 'unknown'}`)
+            return
+        }
+        if (message.action.id === 'RunCommand') {
+            const terminals = vscode.window.terminals
+            let terminal: vscode.Terminal
 
-            const title = message.action.formItemValues?.['prompt-name']
-            const newFilePath = path.join(
-                userPromptsDirectory,
-                title ? `${title}${promptFileExtension}` : `default${promptFileExtension}`
-            )
-            const newFileContent = new Uint8Array(Buffer.from(''))
-            await fs.writeFile(newFilePath, newFileContent)
-            const newFileDoc = await vscode.workspace.openTextDocument(newFilePath)
-            await vscode.window.showTextDocument(newFileDoc)
-            telemetry.ui_click.emit({ elementId: 'amazonq_createSavedPrompt' })
+            if (terminals.length > 0) {
+                terminal = terminals[0]
+            } else {
+                terminal = vscode.window.createTerminal('Amazon Q Terminal')
+            }
+
+            terminal.show()
+
+            const command = session.storedBashCommands[0]
+
+            // Get the current path of the terminal
+            const currentPath = await this.getCurrentTerminalPath(terminal)
+
+            let terminalOutput = ''
+
+            try {
+                // Execute the command in the terminal's current directory
+                const childProcess = new ChildProcess('bash', ['-c', command], {
+                    spawnOptions: { cwd: currentPath },
+                    collect: true,
+                })
+
+                const result = await childProcess.run()
+
+                if (result.exitCode !== 0 || result.error) {
+                    const errorMessage = result.error ? result.error.message : result.stderr
+                    getLogger().error(`Error executing command: ${errorMessage}`)
+                    terminal.sendText(`echo "Error executing command: ${errorMessage}"`)
+                    this.lastTerminalOutput = `Error: ${errorMessage}`
+                } else {
+                    terminalOutput = result.stdout.trim()
+                    terminal.sendText(command)
+                    getLogger().info(`Command executed: ${command}`)
+                    getLogger().info(`Command output: ${terminalOutput}`)
+                    this.lastTerminalOutput = terminalOutput
+                }
+            } catch (error) {
+                const errorMessage = error instanceof Error ? error.message : String(error)
+                getLogger().error(`Error executing command: ${errorMessage}`)
+                terminal.sendText(`echo "Error executing command: ${errorMessage}"`)
+                this.lastTerminalOutput = `Error: ${errorMessage}`
+            }
         }
+        getLogger().error(`Last terminal output: ${this.getLastTerminalOutput()}`)
+        this.messenger.sendMessage(this.getLastTerminalOutput(), message.tabID ?? '', message.tabID ?? 'unknown')
+        session.storedBashCommands = []
+    }
+
+    private async getCurrentTerminalPath(terminal: vscode.Terminal): Promise<string> {
+        try {
+            // Get the current workspace folders
+            const workspaceFolders = vscode.workspace.workspaceFolders
+
+            // Try to get the terminal's creation options
+            // We need to use type assertion since the API types might not expose cwd directly
+            const options = terminal.creationOptions as any
+            if (options) {
+                // Check if cwd exists in the options
+                if (options.cwd) {
+                    if (typeof options.cwd === 'string') {
+                        return options.cwd
+                    } else if (options.cwd instanceof vscode.Uri) {
+                        return options.cwd.fsPath
+                    }
+                }
+            }
+
+            // If there's an active workspace folder, use its path
+            if (workspaceFolders && workspaceFolders.length > 0) {
+                const activeWorkspace = workspaceFolders[0]
+                return activeWorkspace.uri.fsPath
+            }
+
+            // Fallback to user's home directory
+            return os.homedir()
+        } catch (err) {
+            getLogger().error(`Failed to get terminal path: ${err}`)
+            return os.homedir()
+        }
+    }
+
+    // Get the last terminal output
+    public getLastTerminalOutput(): string {
+        return this.lastTerminalOutput
     }
 
     private async processContextSelected(message: ContextSelectedMessage) {

packages/core/src/codewhispererChat/controllers/chat/messenger/messenger.ts

@@ -37,7 +37,7 @@ import { LspController } from '../../../../amazonq/lsp/lspController'
 import { extractCodeBlockLanguage } from '../../../../shared/markdown'
 import { extractAuthFollowUp } from '../../../../amazonq/util/authUtils'
 import { helpMessage } from '../../../../amazonq/webview/ui/texts/constants'
-import { ChatItemButton, ChatItemFormItem, MynahUIDataModel } from '@aws/mynah-ui'
+import { ChatItemButton, ChatItemFormItem, MynahIcons, MynahUIDataModel } from '@aws/mynah-ui'
 
 export type StaticTextResponseType = 'quick-action-help' | 'onboarding-help' | 'transform' | 'help'
 
@@ -313,6 +313,50 @@ export class Messenger {
                     )
                 }
 
+                if (message.includes('```bash')) {
+                    let bashCommand: string | undefined
+                    try {
+                        const bashRegex = /```bash\s*([\s\S]*?)```/
+                        const match = message.match(bashRegex)
+                        if (match && match[1]) {
+                            bashCommand = match[1].trim()
+                            session.storedBashCommands.push(bashCommand)
+                            getLogger().info(`Extracted bash command: ${bashCommand}`)
+                        }
+
+                        const buttons: ChatItemButton[] = []
+                        buttons.push({
+                            keepCardAfterClick: true,
+                            text: 'Run the bash command in terminal',
+                            id: 'RunCommand',
+                            disabled: false, // allow button to be re-clicked
+                            position: 'outside',
+                            icon: 'comment' as MynahIcons,
+                        })
+
+                        this.dispatcher.sendChatMessage(
+                            new ChatMessage(
+                                {
+                                    message: message,
+                                    messageType: 'answer-part',
+                                    followUps: followUps,
+                                    followUpsHeader: undefined,
+                                    relatedSuggestions: undefined,
+                                    triggerID,
+                                    messageID,
+                                    userIntent: triggerPayload.userIntent,
+                                    codeBlockLanguage: undefined,
+                                    contextList: undefined,
+                                    buttons,
+                                },
+                                tabID
+                            )
+                        )
+                    } catch (error) {
+                        const errorMessage = error instanceof Error ? error.message : String(error)
+                        getLogger().error(`Error executing command: ${errorMessage}`)
+                    }
+                }
                 this.dispatcher.sendChatMessage(
                     new ChatMessage(
                         {
@@ -365,6 +409,26 @@ export class Messenger {
         )
     }
 
+    public sendMessage(message: string | undefined, messageID: string, tabID: string) {
+        this.dispatcher.sendChatMessage(
+            new ChatMessage(
+                {
+                    message: message,
+                    messageType: 'answer',
+                    followUps: [],
+                    followUpsHeader: undefined,
+                    relatedSuggestions: undefined,
+                    triggerID: '',
+                    messageID,
+                    userIntent: undefined,
+                    codeBlockLanguage: undefined,
+                    contextList: undefined,
+                },
+                tabID
+            )
+        )
+    }
+
     private editorContextMenuCommandVerbs: Map<EditorContextCommandType, string> = new Map([
         ['aws.amazonq.explainCode', 'Explain'],
         ['aws.amazonq.explainIssue', 'Explain'],

packages/core/src/codewhispererChat/view/connector/connector.ts

@@ -208,6 +208,7 @@ export interface ChatMessageProps {
     readonly userIntent: string | undefined
     readonly codeBlockLanguage: string | undefined
     readonly contextList: DocumentReference[] | undefined
+    readonly buttons?: ChatItemButton[] | undefined
 }
 
 export class ChatMessage extends UiMessage {
@@ -223,6 +224,7 @@ export class ChatMessage extends UiMessage {
     readonly userIntent: string | undefined
     readonly codeBlockLanguage: string | undefined
     readonly contextList: DocumentReference[] | undefined
+    readonly buttons?: ChatItemButton[] | undefined
     override type = 'chatMessage'
 
     constructor(props: ChatMessageProps, tabID: string) {
@@ -238,6 +240,7 @@ export class ChatMessage extends UiMessage {
         this.userIntent = props.userIntent
         this.codeBlockLanguage = props.codeBlockLanguage
         this.contextList = props.contextList
+        this.buttons = props.buttons
     }
 }