Merge pull request #2657 from dotnet/copilot/add-dotnet-getacquisitionlog-command

Add dotnet.getAcquisitionLog command

Author: nagilson

Documentation/commands.md

@@ -124,6 +124,14 @@ This is a **user-facing** command that opens an input box pre-filled with the re
 
 This command surfaces an output channel to the user which provides status messages during extension commands. It does not accept parameters and has a void return type.
 
+### dotnet.getAcquisitionLog
+
+This command returns the full path to the log file that the currently running instance of the extension is writing to, wrapped in an [`IDotnetLogResult`](https://github.com/dotnet/vscode-dotnet-runtime/blob/main/vscode-dotnet-runtime-library/src/IDotnetLogResult.ts) object (containing a `logPath` string). It does not accept parameters. Before returning, it flushes any buffered log entries to disk so the file reflects the latest state.
+
+Note: Each VS Code window gets its own extension host log folder, so the returned path only points to the log for the current window. Other concurrent VS Code instances (for example VS Code Insiders versus VS Code) maintain their own logs and must invoke this command separately. The path is derived from `ExtensionContext.logPath`, which [VS Code constructs from the log URI's `fsPath`](https://github.com/microsoft/vscode/blob/a837f16fbe459f3a067aa94da0ddb9b9ae04ebe0/src/vs/workbench/api/common/extHostExtensionService.ts#L538), so it should reflect the remote/WSL extension host when the extension runs there; this is the behavior as of 4/21/2026, despite that VS Code's own commands to get the log path return the Windows path on WSL.
+
+**Offline behavior:** Works offline.
+
 ### dotnet.ensureDotnetDependencies
 
 This command is only applicable to Linux machines. It attempts to ensure that .NET dependencies are present and, if they are not, installs them or prompts the user to do so. It accepts a [IDotnetEnsureDependenciesContext](https://github.com/dotnet/vscode-dotnet-runtime/blob/main/vscode-dotnet-runtime-library/src/IDotnetEnsureDependenciesContext.ts) object and has a void return type. It is no longer supported but remains to support legacy behavior.

sample/package.json

@@ -65,6 +65,11 @@
 				"title": "Show .NET runtime acquisition log",
 				"category": "Sample"
 			},
+			{
+				"command": "sample.dotnet.getAcquisitionLog",
+				"title": "Get the .NET runtime acquisition log file path",
+				"category": "Sample"
+			},
 			{
 				"command": "sample.dotnet.acquireGlobalSDK",
 				"title": "Install .NET SDK Globally via .NET Install Tool (Former Runtime Extension)",

sample/src/extension.ts

@@ -15,6 +15,7 @@ import
     IDotnetAcquireResult,
     IDotnetFindPathContext,
     IDotnetListVersionsResult,
+    IDotnetLogResult,
 } from 'vscode-dotnet-runtime-library';
 
 export function activate(context: vscode.ExtensionContext)
@@ -222,6 +223,19 @@ ${stderr}`);
         }
     });
 
+    const sampleGetAcquisitionLogRegistration = vscode.commands.registerCommand('sample.dotnet.getAcquisitionLog', async () =>
+    {
+        try
+        {
+            const result = await vscode.commands.executeCommand<IDotnetLogResult>('dotnet.getAcquisitionLog');
+            vscode.window.showInformationMessage(`.NET acquisition log path: ${result?.logPath ?? 'undefined'}`);
+        }
+        catch (error)
+        {
+            vscode.window.showErrorMessage((error as Error).toString());
+        }
+    });
+
     const sampleGlobalSDKFromRuntimeRegistration = vscode.commands.registerCommand('sample.dotnet.acquireGlobalSDK', async (version) =>
     {
         if (!version)
@@ -334,6 +348,7 @@ ${JSON.stringify(result) ?? 'undefined'}`);
         sampleConcurrentTest,
         sampleConcurrentASPNETTest,
         sampleShowAcquisitionLogRegistration,
+        sampleGetAcquisitionLogRegistration,
         sampleFindPathRegistration,
         sampleAvailableInstallsRegistration
     );

sample/yarn.lock

@@ -57,6 +57,7 @@ import
     IDotnetListInfo,
     IDotnetListVersionsContext,
     IDotnetListVersionsResult,
+    IDotnetLogResult,
     IDotnetSearchContext,
     IDotnetSearchResult,
     IDotnetUninstallContext,
@@ -122,6 +123,7 @@ namespace commandKeys
     export const recommendedVersion = 'recommendedVersion'
     export const globalAcquireSDKPublic = 'acquireGlobalSDKPublic';
     export const showAcquisitionLog = 'showAcquisitionLog';
+    export const getAcquisitionLog = 'getAcquisitionLog';
     export const ensureDotnetDependencies = 'ensureDotnetDependencies';
     export const reportIssue = 'reportIssue';
     export const resetData = 'resetData';
@@ -821,6 +823,13 @@ ${JSON.stringify(commandContext)}`));
 
     const showOutputChannelRegistration = vscode.commands.registerCommand(`${commandPrefix}.${commandKeys.showAcquisitionLog}`, () => outputChannelObserver.showOutput());
 
+    const getAcquisitionLogRegistration = vscode.commands.registerCommand(`${commandPrefix}.${commandKeys.getAcquisitionLog}`, async (): Promise<IDotnetLogResult> =>
+    {
+        // Flush any buffered log entries so the file on disk reflects the latest state.
+        await loggingObserver.flush();
+        return { logPath: loggingObserver.getFileLocation() };
+    });
+
     const ensureDependenciesRegistration = vscode.commands.registerCommand(`${commandPrefix}.${commandKeys.ensureDotnetDependencies}`, async (commandContext: IDotnetEnsureDependenciesContext) =>
     {
         await callWithErrorHandling(async () =>
@@ -1024,6 +1033,7 @@ Installation will timeout in ${timeoutValue} seconds.`))
         dotnetUninstallAllRegistration,
         dotnetForceUpdateRegistration,
         showOutputChannelRegistration,
+        getAcquisitionLogRegistration,
         ensureDependenciesRegistration,
         reportIssueRegistration,
         resetUpdateTimerInternalRegistration,

vscode-dotnet-runtime-extension/src/extension.ts

@@ -31,6 +31,7 @@ import
     IDotnetFindPathContext,
     IDotnetListVersionsContext,
     IDotnetListVersionsResult,
+    IDotnetLogResult,
     IDotnetSearchContext,
     IDotnetSearchResult,
     IExistingPaths,
@@ -139,6 +140,28 @@ suite('DotnetCoreAcquisitionExtension End to End', function ()
         assert.deepEqual((mockState as any).syncedKeys, [], 'setKeysForSync should be called with empty array to prevent syncing install state');
     }).timeout(standardTimeoutTime);
 
+    test('dotnet.getAcquisitionLog returns the path to the current log file', async () =>
+    {
+        const result = await vscode.commands.executeCommand<IDotnetLogResult>('dotnet.getAcquisitionLog');
+        assert.exists(result, 'dotnet.getAcquisitionLog returns a value');
+        assert.exists(result!.logPath, 'dotnet.getAcquisitionLog result contains logPath');
+        assert.isString(result!.logPath, 'dotnet.getAcquisitionLog returns a string logPath');
+        assert.isTrue(result!.logPath.length > 0, 'dotnet.getAcquisitionLog returns a non-empty path');
+        // The log file is named like `DotNetAcquisition-<extensionId>-<timestamp>.txt`
+        // (see EventStreamRegistration.ts). Validate the filename shape so callers know
+        // they are being handed the acquisition log rather than some other file.
+        assert.include(path.basename(result!.logPath), 'DotNetAcquisition', 'Returned path points at a DotNetAcquisition log file');
+        assert.isTrue(result!.logPath.endsWith('.txt'), 'Returned log file has a .txt extension');
+        // The directory containing the log should exist after activation even if no log
+        // lines have been flushed yet; ensureDirectory is invoked on flush.
+        assert.isTrue(fs.existsSync(path.dirname(result!.logPath)), 'Log directory exists');
+        // Activation performs JSON scanning which should always produce at least one
+        // log entry, so the file should exist and be non-empty after awaiting flush.
+        assert.isTrue(fs.existsSync(result!.logPath), 'Log file exists on disk');
+        const logContents = fs.readFileSync(result!.logPath, 'utf8');
+        assert.isTrue(logContents.length > 0, 'Log file is non-empty after activation');
+    }).timeout(standardTimeoutTime);
+
     async function installRuntime(dotnetVersion: string, installMode: DotnetInstallMode, arch?: string)
     {
         let context: IDotnetAcquireContext = { version: dotnetVersion, requestingExtensionId, mode: installMode };

vscode-dotnet-runtime-extension/src/test/functional/DotnetCoreAcquisitionExtension.test.ts

@@ -0,0 +1,13 @@
+/*---------------------------------------------------------------------------------------------
+*  Licensed to the .NET Foundation under one or more agreements.
+*  The .NET Foundation licenses this file to you under the MIT license.
+*--------------------------------------------------------------------------------------------*/
+
+/**
+ * The result of the dotnet.getAcquisitionLog command.
+ * Contains the full path to the log file for this VS Code window/instance
+ * of the .NET Install Tool extension.
+ */
+export interface IDotnetLogResult {
+    logPath: string;
+}

vscode-dotnet-runtime-library/src/IDotnetLogResult.ts

@@ -47,6 +47,7 @@ export * from './IDotnetAcquireContext';
 export * from './IDotnetAcquireResult';
 export * from './IDotnetEnsureDependenciesContext';
 export * from './IDotnetFindPathContext';
+export * from './IDotnetLogResult';
 export * from './IDotnetListVersionsContext';
 export * from './IDotnetSearchContext';
 export * from './IDotnetSearchResult';