feat(amazonq): skip registering run command log file

Author: karanA-aws

packages/amazonq/.changes/next-release/Feature-86f056f5-4ac4-47be-8167-09c19a529a1e.json

@@ -0,0 +1,4 @@
+{
+	"type": "Feature",
+	"description": "The logs emitted by the Agent during user command execution will be accepted and written to .amazonq/dev/run_command.log file in the user's local repository."
+}

packages/core/src/amazonq/session/sessionState.ts

@@ -4,6 +4,7 @@
  */
 
 import * as vscode from 'vscode'
+import * as path from 'path'
 import { ToolkitError } from '../../shared/errors'
 import globals from '../../shared/extensionGlobals'
 import { getLogger } from '../../shared/logger/logger'
@@ -27,8 +28,10 @@ import {
 } from '../commons/types'
 import { prepareRepoData, getDeletedFileInfos, registerNewFiles, PrepareRepoDataOptions } from '../util/files'
 import { uploadCode } from '../util/upload'
+import fss from '../../shared/fs/fs'
 
 export const EmptyCodeGenID = 'EMPTY_CURRENT_CODE_GENERATION_ID'
+export const RunCommandLogFileName = '.amazonq/dev/run_command.log'
 
 export interface BaseMessenger {
     sendAnswer(params: any): void
@@ -103,6 +106,29 @@ export abstract class CodeGenBase {
                 case CodeGenerationStatus.COMPLETE: {
                     const { newFileContents, deletedFiles, references } =
                         await this.config.proxyClient.exportResultArchive(this.conversationId)
+
+                    const logFileInfo = newFileContents.find(
+                        (file: { zipFilePath: string; fileContent: string }) =>
+                            file.zipFilePath === RunCommandLogFileName
+                    )
+                    if (logFileInfo) {
+                        const filePath = path.join(this.config.workspaceRoots[0], RunCommandLogFileName)
+                        const fileUri = vscode.Uri.file(filePath)
+
+                        try {
+                            const content = Uint8Array.from(Buffer.from(logFileInfo.fileContent))
+                            const decodedContent = new TextDecoder().decode(content)
+                            await fss.mkdir(path.dirname(fileUri.fsPath))
+                            await fss.writeFile(fileUri.fsPath, decodedContent)
+                        } catch (e) {
+                            const errorDetails =
+                                e instanceof Error ? `${e.name}: ${e.message}\nStack Trace: ${e.stack}` : String(e)
+                            getLogger().error(`Error writing log file. Details: ${errorDetails}`)
+                        }
+
+                        newFileContents.splice(newFileContents.indexOf(logFileInfo), 1)
+                    }
+
                     const newFileInfo = registerNewFiles(
                         fs,
                         newFileContents,

packages/core/src/shared/virtualFilesystem.ts

@@ -46,7 +46,6 @@ export class VirtualFileSystem implements vscode.FileSystemProvider {
         if (this.fileProviders[key] !== undefined) {
             throw new Error('Cannot re-register a provider for the same URI')
         }
-
         this.fileProviders[key] = provider
         const onDidChange = provider.onDidChange(() => {
             this._onDidChangeFile.fire([{ uri, type: vscode.FileChangeType.Changed }])

packages/core/src/test/amazonqDoc/session/sessionState.test.ts

@@ -8,8 +8,12 @@ import assert from 'assert'
 import sinon from 'sinon'
 import { DocPrepareCodeGenState } from '../../../amazonqDoc'
 import { createMockSessionStateAction } from '../../amazonq/utils'
-
 import { createTestContext, setupTestHooks } from '../../amazonq/session/testSetup'
+import * as filesModule from '../../../amazonq/util/files'
+import { CodeGenBase } from '../../../amazonq/session/sessionState'
+import { RunCommandLogFileName } from '../../../amazonq/session/sessionState'
+import fss from '../../../shared/fs/fs'
+import path from 'path'
 
 describe('sessionStateDoc', () => {
     const context = createTestContext()
@@ -26,4 +30,173 @@ describe('sessionStateDoc', () => {
             })
         })
     })
+
+    describe('CodeGenBase generateCode log file handling', () => {
+        // Minimal implementation of TestCodeGen to test generateCode.
+        class TestCodeGen extends CodeGenBase {
+            public generatedFiles: any[] = []
+            constructor(config: any, tabID: string) {
+                super(config, tabID)
+            }
+            protected handleProgress(_messenger: any): void {
+                // No-op for test.
+            }
+            protected getScheme(): string {
+                return 'file'
+            }
+            protected getTimeoutErrorCode(): string {
+                return 'test_timeout'
+            }
+            protected handleGenerationComplete(_messenger: any, newFileInfo: any[]): void {
+                this.generatedFiles = newFileInfo
+            }
+            protected handleError(_messenger: any, _codegenResult: any): Error {
+                throw new Error('handleError called')
+            }
+        }
+
+        let fakeProxyClient: any
+        let testConfig: any
+        let fsMock: any
+        let messengerMock: any
+        let telemetryMock: any
+        let testAction: any
+        let registerNewFilesStub: any
+        let mkdirStub: any
+        let writeFileStub: any
+
+        beforeEach(() => {
+            fakeProxyClient = {
+                getCodeGeneration: sinon.stub().resolves({
+                    codeGenerationStatus: { status: 'Complete' },
+                    codeGenerationRemainingIterationCount: 0,
+                    codeGenerationTotalIterationCount: 1,
+                }),
+                exportResultArchive: sinon.stub(),
+            }
+
+            testConfig = {
+                conversationId: 'conv_test',
+                uploadId: 'upload_test',
+                workspaceRoots: ['/workspace'],
+                workspaceFolders: {} as any,
+                proxyClient: fakeProxyClient,
+                currentCodeGenerationId: 'test_gen',
+            }
+
+            fsMock = {
+                writeFile: sinon.stub().resolves(),
+            }
+
+            messengerMock = { sendAnswer: sinon.spy() }
+
+            telemetryMock = {
+                setCodeGenerationResult: sinon.spy(),
+                setNumberOfFilesGenerated: sinon.spy(),
+                setAmazonqNumberOfReferences: sinon.spy(),
+                setGenerateCodeIteration: sinon.spy(),
+                setGenerateCodeLastInvocationTime: sinon.spy(),
+                recordUserCodeGenerationTelemetry: sinon.spy(),
+            }
+
+            testAction = {
+                fs: fsMock,
+                messenger: messengerMock,
+                tokenSource: { token: { isCancellationRequested: false, onCancellationRequested: () => {} } },
+                telemetry: telemetryMock,
+                uploadHistory: {},
+            }
+
+            registerNewFilesStub = sinon
+                .stub(filesModule, 'registerNewFiles')
+                .callsFake((_, newFileContents: any[]) => {
+                    return newFileContents
+                })
+
+            mkdirStub = sinon.stub(fss, 'mkdir').resolves()
+            writeFileStub = sinon.stub(fss, 'writeFile').resolves()
+        })
+
+        afterEach(() => {
+            sinon.restore()
+        })
+
+        it('writes the log file if present and removes it from new files', async () => {
+            const logFileInfo = {
+                zipFilePath: RunCommandLogFileName,
+                fileContent: 'newLog',
+            }
+            const otherFile = { zipFilePath: 'other.ts', fileContent: 'other content' }
+            fakeProxyClient.exportResultArchive.resolves({
+                newFileContents: [logFileInfo, otherFile],
+                deletedFiles: [],
+                references: [],
+            })
+
+            const testCodeGen = new TestCodeGen(testConfig, 'tab1')
+
+            const result = await testCodeGen.generateCode({
+                messenger: messengerMock,
+                fs: fsMock,
+                codeGenerationId: 'codegen1',
+                telemetry: telemetryMock,
+                workspaceFolders: {} as any,
+                action: testAction,
+            })
+
+            const expectedFilePath = path.join(testConfig.workspaceRoots[0], RunCommandLogFileName)
+            const fileUri = vscode.Uri.file(expectedFilePath)
+
+            // Verify mkdir and writeFile have been called with the expected arguments.
+            sinon.assert.calledWith(mkdirStub, path.dirname(fileUri.fsPath))
+            sinon.assert.calledWith(writeFileStub, fileUri.fsPath, 'newLog')
+
+            // Verify that registerNewFiles received only the "otherFile" (i.e. log file removed)
+            sinon.assert.calledWith(
+                registerNewFilesStub,
+                fsMock,
+                [otherFile],
+                testConfig.uploadId,
+                {} as any,
+                testConfig.conversationId,
+                'file'
+            )
+            assert.deepStrictEqual(result.newFiles, [otherFile])
+        })
+
+        it('skips log file handling if log file is not present', async () => {
+            const file1 = { zipFilePath: 'file1.ts', fileContent: 'content1' }
+            fakeProxyClient.exportResultArchive.resolves({
+                newFileContents: [file1],
+                deletedFiles: [],
+                references: [],
+            })
+
+            const testCodeGen = new TestCodeGen(testConfig, 'tab1')
+
+            const result = await testCodeGen.generateCode({
+                messenger: messengerMock,
+                fs: fsMock,
+                codeGenerationId: 'codegen2',
+                telemetry: telemetryMock,
+                workspaceFolders: {} as any,
+                action: testAction,
+            })
+
+            // Verify that mkdir and writeFile were not called because no log file exists.
+            sinon.assert.notCalled(mkdirStub)
+            sinon.assert.notCalled(writeFileStub)
+            // Verify that the registered new files are the same as provided.
+            sinon.assert.calledWith(
+                registerNewFilesStub,
+                fsMock,
+                [file1],
+                testConfig.uploadId,
+                {} as any,
+                testConfig.conversationId,
+                'file'
+            )
+            assert.deepStrictEqual(result.newFiles, [file1])
+        })
+    })
 })