extension.ts

/*---------------------------------------------------------------------------------------------
*  Licensed to the .NET Foundation under one or more agreements.
*  The .NET Foundation licenses this file to you under the MIT license.
*--------------------------------------------------------------------------------------------*/

import * as cp from 'child_process';
import * as fs from 'fs';
import * as os from 'os';
import * as path from 'path';
import * as vscode from 'vscode';
import
{
    AcquireErrorConfiguration,
    AcquisitionInvoker,
    callWithErrorHandling,
    CommandExecutor,
    directoryProviderFactory,
    DotnetAcquisitionMissingLinuxDependencies,
    DotnetAcquisitionRequested,
    DotnetAcquisitionStatusRequested,
    DotnetAcquisitionTotalSuccessEvent,
    DotnetConditionValidator,
    DotnetCoreAcquisitionWorker,
    DotnetCoreDependencyInstaller,
    DotnetExistingPathResolutionCompleted,
    DotnetFindPathCommandInvoked,
    DotnetFindPathLookupSetting,
    DotnetFindPathMetCondition,
    DotnetFindPathNoPathMetCondition,
    DotnetFindPathSettingFound,
    DotnetHostPathFinder,
    DotnetInstall,
    DotnetInstallMode,
    DotnetInstallType,
    DotnetOfflineWarning,
    DotnetResolver,
    DotnetVersionCategorizedEvent,
    DotnetVersionResolutionError,
    DotnetVersionSpecRequirement,
    enableExtensionTelemetry,
    ErrorConfiguration,
    EventBasedError,
    EventCancellationError,
    ExistingPathResolver,
    ExtensionConfigurationWorker,
    formatIssueUrl,
    getInstallIdCustomArchitecture,
    getMajor,
    getMajorMinor,
    GlobalAcquisitionContextMenuOpened,
    GlobalInstallerResolver,
    IAcquisitionWorkerContext,
    IDotnetAcquireContext,
    IDotnetAcquireResult,
    IDotnetConditionValidator,
    IDotnetEnsureDependenciesContext,
    IDotnetFindPathContext,
    IDotnetListInfo,
    IDotnetListVersionsContext,
    IDotnetListVersionsResult,
    IDotnetLogResult,
    IDotnetSearchContext,
    IDotnetSearchResult,
    IDotnetUninstallContext,
    IDotnetVersion,
    IEventStream,
    IEventStreamContext,
    IExtensionContext,
    IIssueContext,
    InstallationValidator,
    InstallRecord,
    InvalidUninstallRequest,
    IUtilityContext,
    JsonInstaller,
    LanguageModelToolsRegistrationError,
    LinuxVersionResolver,
    LocalInstallUpdateService,
    LocalMemoryCacheSingleton,
    NoExtensionIdProvided,
    registerEventStream,
    UninstallErrorConfiguration,
    UserManualInstallFailure,
    UserManualInstallRequested,
    UserManualInstallSuccess,
    UserManualInstallVersionChosen,
    VersionResolver,
    VSCodeEnvironment,
    VSCodeExtensionContext,
    WebRequestWorkerSingleton,
    WindowDisplayWorker
} from 'vscode-dotnet-runtime-library';
import { InstallTrackerSingleton } from 'vscode-dotnet-runtime-library/dist/Acquisition/InstallTrackerSingleton';
import { EventStreamTaggingDecorator } from 'vscode-dotnet-runtime-library/dist/EventStream/EventStreamTaggingDecorator';
import { dotnetCoreAcquisitionExtensionId } from './DotnetCoreAcquisitionId';
import { registerLanguageModelTools } from './LanguageModelTools';
import open = require('open');

const packageJson = require('../package.json');

// Extension constants
namespace configKeys
{
    export const installTimeoutValue = 'installTimeoutValue';
    export const enableTelemetry = 'enableTelemetry';
    export const existingPath = 'existingDotnetPath';
    export const existingSharedPath = 'sharedExistingDotnetPath'
    export const proxyUrl = 'proxyUrl';
    export const allowInvalidPaths = 'allowInvalidPaths';
    export const cacheTimeToLiveMultiplier = 'cacheTimeToLiveMultiplier';
    export const showResetDataCommand = 'showResetDataCommand';
    export const suppressOutput = 'suppressOutput';
    export const highVerbosity = 'highVerbosity';
    export const runtimeUpdateDelaySeconds = 'runtimeUpdateDelaySeconds';
    export const enableLanguageModelTools = 'enableLanguageModelTools';
}

namespace commandKeys
{
    export const acquire = 'acquire';
    export const acquireGlobalSDK = 'acquireGlobalSDK';
    export const acquireStatus = 'acquireStatus';
    export const uninstall = 'uninstall';
    export const findPath = 'findPath';
    export const uninstallPublic = 'uninstallPublic'
    export const uninstallAll = 'uninstallAll';
    export const listVersions = 'listVersions';
    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';
    export const availableInstalls = 'availableInstalls';
    export const resetUpdateTimerInternal = '_resetUpdateTimer';
}

const commandPrefix = 'dotnet';
const configPrefix = 'dotnetAcquisitionExtension';
const displayChannelName = '.NET Install Tool';
const defaultTimeoutValue = 600;
const moreInfoUrl = 'https://github.com/dotnet/vscode-dotnet-runtime/blob/main/Documentation/troubleshooting-runtime.md';
let disableActivationUnderTest = true;
let extensionEventStream: IEventStream | undefined;
let extensionGlobalState: vscode.Memento | undefined;

export function activate(vsCodeContext: vscode.ExtensionContext, extensionContext?: IExtensionContext)
{
    // All globalState keys are machine-specific (install paths, session tracking, etc.)
    // and must not be synced to other machines or dev containers via Settings Sync.
    vsCodeContext.globalState.setKeysForSync?.([]);

    if ((process.env.DOTNET_INSTALL_TOOL_UNDER_TEST === 'true' || (vsCodeContext?.extensionMode === vscode.ExtensionMode.Test)) && disableActivationUnderTest)
    {
        return;
    }

    // Loading Extension Configuration
    const extensionConfiguration = extensionContext !== undefined && extensionContext.extensionConfiguration ?
        extensionContext.extensionConfiguration :
        vscode.workspace.getConfiguration(configPrefix);

    // Reading Extension Configuration
    const timeoutValue = extensionConfiguration.get<number>(configKeys.installTimeoutValue);
    if (!fs.existsSync(vsCodeContext.globalStoragePath))
    {
        fs.mkdirSync(vsCodeContext.globalStoragePath, { recursive: true });
    }
    const resolvedTimeoutSeconds = timeoutValue === undefined ? defaultTimeoutValue : timeoutValue;
    const runtimeUpdateDelaySeconds = extensionConfiguration.get<number>(configKeys.runtimeUpdateDelaySeconds) ?? 300;
    const runtimeUpdateDelayMs = runtimeUpdateDelaySeconds * 1000;
    const proxyLink = extensionConfiguration.get<string>(configKeys.proxyUrl);
    const showResetDataCommand = extensionConfiguration.get<boolean>(configKeys.showResetDataCommand);

    // Create a cache with the TTL setting that we can only reasonably access from here.
    const cacheTimeToLiveMultiplier = Math.abs(Number(extensionConfiguration.get<string>(configKeys.cacheTimeToLiveMultiplier) ?? 1)) ?? 1;
    const _localCache = LocalMemoryCacheSingleton.getInstance(cacheTimeToLiveMultiplier);


    const allowInvalidPathSetting = extensionConfiguration.get<boolean>(configKeys.allowInvalidPaths);
    const suppressOutput = extensionConfiguration.get<boolean>(configKeys.suppressOutput) ?? false;
    const highVerbosity = extensionConfiguration.get<boolean>(configKeys.highVerbosity) ?? false;
    const isExtensionTelemetryEnabled = enableExtensionTelemetry(extensionConfiguration, configKeys.enableTelemetry);
    const displayWorker = extensionContext ? extensionContext.displayWorker : new WindowDisplayWorker();

    // Creating Contexts to Execute Under
    const utilContext = {
        ui: displayWorker,
        vsCodeEnv: new VSCodeEnvironment()
    }

    const vsCodeExtensionContext = new VSCodeExtensionContext(vsCodeContext);
    const eventStreamContext = {
        displayChannelName,
        logPath: vsCodeContext.logPath,
        extensionId: dotnetCoreAcquisitionExtensionId,
        enableTelemetry: isExtensionTelemetryEnabled,
        telemetryReporter: extensionContext ? extensionContext.telemetryReporter : undefined,
        showLogCommand: `${commandPrefix}.${commandKeys.showAcquisitionLog}`,
        packageJson
    } as IEventStreamContext;
    const [globalEventStream, outputChannelObserver, loggingObserver,
        eventStreamObservers, telemetryObserver, _] = registerEventStream(eventStreamContext, vsCodeExtensionContext, utilContext, suppressOutput, highVerbosity);


    const runtimeUpdateDirectoryProvider = directoryProviderFactory(
        'runtime', vsCodeContext.globalStoragePath); // Assumption : aspnetcore and runtime directory provider use the same logic, otherwise updates would not be found
    const automaticUpdater = new LocalInstallUpdateService(globalEventStream, vsCodeContext.globalState, runtimeUpdateDirectoryProvider,
        acquireLocal,
        uninstall,
        loggingObserver
    );

    if (!(process.env.DOTNET_INSTALL_TOOL_UNDER_TEST === 'true')) // Don't try to update while testing - this would make tests fail randomly
    {
        automaticUpdater.ManageInstalls(runtimeUpdateDelayMs).catch((e: any) =>
        {
            if (!suppressOutput)
            {
                // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
                vscode.window.showWarningMessage(`The .NET Runtime may be out of date. An error occurred while checking for updates: ${e?.message ?? JSON.stringify(e)}.`);
            }
        });
    }

    // Setting up command-shared classes for Runtime & SDK Acquisition
    const existingPathConfigWorker = new ExtensionConfigurationWorker(extensionConfiguration, configKeys.existingPath, configKeys.existingSharedPath);

    // Creating API Surfaces
    const dotnetAcquireRegistration = vscode.commands.registerCommand(`${commandPrefix}.${commandKeys.acquire}`, async (commandContext: IDotnetAcquireContext): Promise<IDotnetAcquireResult | undefined> =>
    {
        return acquireLocal(commandContext);
    });

    async function acquireLocal(commandContext: IDotnetAcquireContext, ignorePathSetting = false): Promise<IDotnetAcquireResult | undefined>
    {
        const worker = getAcquisitionWorker();
        commandContext.mode = commandContext.mode ?? 'runtime' as DotnetInstallMode;
        const mode = commandContext.mode;

        const workerContext = getAcquisitionWorkerContext(mode, commandContext);

        const dotnetPath = await callWithErrorHandling<Promise<IDotnetAcquireResult>>(async () =>
        {
            globalEventStream.post(new DotnetAcquisitionRequested(commandContext.version, commandContext.requestingExtensionId ?? 'notProvided', mode, commandContext.installType ?? 'local'));

            telemetryObserver?.setAcquisitionContext(workerContext, commandContext);

            if (!commandContext.requestingExtensionId)
            {
                globalEventStream.post(new NoExtensionIdProvided(`No requesting extension id was provided for the request ${commandContext.version}.`));
                vscode.window.showWarningMessage(`One of your extensions is attempting to install .NET without providing an extension id.
                This install cannot be properly maintained. Please report this to the extension author.`);
            }

            if (!commandContext.version || commandContext.version === 'latest')
            {
                throw new EventBasedError('BadContextualVersion',
                    `Cannot acquire .NET version "${commandContext.version}". Please provide a valid version.`);
            }

            if (!ignorePathSetting)
            {
                const existingPath = await resolveExistingPathIfExists(existingPathConfigWorker, commandContext, workerContext, utilContext);
                if (existingPath)
                {
                    return existingPath;
                }
            }

            // If a fully specified version (e.g., 8.0.19) is requested and forceUpdate is undefined,
            // set forceUpdate to true to skip the existing installation check and install the specific version requested.
            if (commandContext.version.split('.').length > 2 && commandContext.forceUpdate === undefined)
            {
                commandContext.forceUpdate = true;
            }

            const isOffline = !(await WebRequestWorkerSingleton.getInstance().isOnline(timeoutValue ?? defaultTimeoutValue, globalEventStream));
            if (!commandContext.forceUpdate || isOffline)
            {
                // 3.0 Breaking Change: Don't always return latest .NET runtime by default
                // Always use offline install matching the major.minor if it exists, unless forceUpdate is set (forceUpdate enables the legacy behavior of always returning the latest .NET runtime)
                const existingOfflinePath = await getExistingInstallOffline(worker, workerContext);
                if (existingOfflinePath)
                {
                    return Promise.resolve(existingOfflinePath);
                }
            }

            // Note: This will impact the context object given to the worker and error handler since objects own a copy of a reference in JS.
            const runtimeVersionResolver = new VersionResolver(workerContext);
            commandContext.version = commandContext.version.split('.')?.length > 2 ? commandContext.version : await runtimeVersionResolver.getFullVersion(commandContext.version, mode);

            const acquisitionInvoker = new AcquisitionInvoker(workerContext, utilContext);
            return mode === 'aspnetcore' ? worker.acquireLocalASPNET(workerContext, acquisitionInvoker) : worker.acquireLocalRuntime(workerContext, acquisitionInvoker);
        }, getIssueContext(existingPathConfigWorker)(commandContext.errorConfiguration, 'acquire', commandContext.version), commandContext.requestingExtensionId, workerContext);

        const installationId = getInstallIdCustomArchitecture(commandContext.version, commandContext.architecture, mode, 'local');
        const install = {
            installId: installationId, version: commandContext.version, installMode: mode, isGlobal: false,
            architecture: commandContext.architecture ?? DotnetCoreAcquisitionWorker.defaultArchitecture()
        } as DotnetInstall;

        if (dotnetPath !== undefined && dotnetPath?.dotnetPath)
        {
            globalEventStream.post(new DotnetAcquisitionTotalSuccessEvent(commandContext.version, install, commandContext.requestingExtensionId ?? '', dotnetPath.dotnetPath));
        }

        void loggingObserver.flush();
        return dotnetPath;
    }

    const dotnetAcquireGlobalSDKRegistration = vscode.commands.registerCommand(`${commandPrefix}.${commandKeys.acquireGlobalSDK}`, async (commandContext: IDotnetAcquireContext): Promise<IDotnetAcquireResult | undefined> =>
    {
        commandContext.mode = commandContext.mode ?? 'sdk' as DotnetInstallMode;

        if (commandContext.requestingExtensionId === undefined)
        {
            return Promise.reject(new Error('No requesting extension id was provided.'));
        }

        let fullyResolvedVersion = '';
        const workerContext = getAcquisitionWorkerContext(commandContext.mode, commandContext);
        const worker = getAcquisitionWorker();

        const pathResult = await callWithErrorHandling(async () =>
        {
            // Warning: Between now and later in this call-stack, the context 'version' is incomplete as it has not been resolved.
            // Errors between here and the place where it is resolved cannot be routed to one another.

            telemetryObserver?.setAcquisitionContext(workerContext, commandContext);

            if (commandContext.version === '' || !commandContext.version)
            {
                throw new EventCancellationError('BadContextualRuntimeVersionError',
                    `No version was defined to install.`);
            }

            globalEventStream.post(new DotnetAcquisitionRequested(commandContext.version, commandContext.requestingExtensionId ?? 'notProvided', commandContext.mode!, commandContext.installType ?? 'global'));

            const existingOfflinePath = await getExistingInstallIfOffline(worker, workerContext);
            if (existingOfflinePath)
            {
                return Promise.resolve(existingOfflinePath);
            }

            const globalInstallerResolver = new GlobalInstallerResolver(workerContext, commandContext.version);
            fullyResolvedVersion = await globalInstallerResolver.getFullySpecifiedVersion();

            // Reset context to point to the fully specified version so it is not possible for someone to access incorrect data during the install process.
            // Note: This will impact the context object given to the worker and error handler since objects own a copy of a reference in JS.
            commandContext.version = fullyResolvedVersion;
            telemetryObserver?.setAcquisitionContext(workerContext, commandContext);

            outputChannelObserver.showOutput();
            const dotnetPath = await worker.acquireGlobalSDK(workerContext, globalInstallerResolver);

            // setPathEnvVar expects the directory holding the dotnet executable, not the executable file itself.
            new CommandExecutor(workerContext, utilContext).setPathEnvVar(path.dirname(dotnetPath.dotnetPath), moreInfoUrl, displayWorker, vsCodeExtensionContext, true);
            return dotnetPath;
        }, getIssueContext(existingPathConfigWorker)(commandContext.errorConfiguration, commandKeys.acquireGlobalSDK), commandContext.requestingExtensionId, workerContext, commandContext.rethrowError);

        const installationId = getInstallIdCustomArchitecture(commandContext.version, commandContext.architecture, commandContext.mode, 'global');
        const install = {
            installId: installationId, version: commandContext.version, installMode: commandContext.mode, isGlobal: true,
            architecture: commandContext.architecture ?? DotnetCoreAcquisitionWorker.defaultArchitecture()
        } as DotnetInstall;

        if (pathResult !== undefined && pathResult?.dotnetPath)
        {
            globalEventStream.post(new DotnetAcquisitionTotalSuccessEvent(commandContext.version, install, commandContext.requestingExtensionId ?? '', pathResult.dotnetPath));
        }

        void loggingObserver.flush();
        return pathResult;
    });

    const dotnetListVersionsRegistration = vscode.commands.registerCommand(`${commandPrefix}.${commandKeys.listVersions}`,
        async (commandContext: IDotnetListVersionsContext | undefined, customWebWorker: WebRequestWorkerSingleton | undefined): Promise<IDotnetListVersionsResult | undefined> =>
        {
            return getAvailableVersions(commandContext, customWebWorker, false);
        });

    const dotnetRecommendedVersionRegistration = vscode.commands.registerCommand(`${commandPrefix}.${commandKeys.recommendedVersion}`,
        async (commandContext: IDotnetListVersionsContext | undefined, customWebWorker: WebRequestWorkerSingleton | undefined): Promise<IDotnetListVersionsResult> =>
        {
            const recommendation = await callWithErrorHandling(async () =>
            {
                const availableVersions = await getAvailableVersions(commandContext, customWebWorker, true) ?? [];
                const activeSupportVersions = availableVersions?.filter((version: IDotnetVersion) => version.supportPhase === 'active');

                if (!activeSupportVersions || (activeSupportVersions?.length ?? 0) < 1)
                {
                    const err = new EventCancellationError('DotnetVersionResolutionError', `An active-support version of dotnet couldn't be found. Discovered versions: ${JSON.stringify(availableVersions)}`);
                    globalEventStream.post(new DotnetVersionResolutionError(err, null));
                    if (!availableVersions || (availableVersions?.length ?? 0) < 1)
                    {
                        return [];
                    }
                    else
                    {
                        return [availableVersions[0]];
                    }
                }

                // The first item will be the newest version.
                return [activeSupportVersions[0]];
            }, getIssueContext(existingPathConfigWorker)(commandContext?.errorConfiguration, 'acquireStatus'));

            return recommendation ?? [];
        });


    const acquireGlobalSDKPublicRegistration = vscode.commands.registerCommand(`${commandPrefix}.${commandKeys.globalAcquireSDKPublic}`, async (commandContext: IDotnetAcquireContext | undefined) =>
    {
        globalEventStream.post(new GlobalAcquisitionContextMenuOpened(`The user has opened the global SDK acquisition context menu.`));

        const recommendedVersionResult: IDotnetListVersionsResult = await vscode.commands.executeCommand('dotnet.recommendedVersion', { listRuntimes: false, errorConfiguration: commandContext?.errorConfiguration } as IDotnetListVersionsContext);
        globalEventStream.post(new DotnetVersionCategorizedEvent(`Recommended versions: ${JSON.stringify(recommendedVersionResult ?? '')}.`));


        const recommendedVersion: string = recommendedVersionResult ? recommendedVersionResult[0]?.version : '';
        globalEventStream.post(new DotnetVersionCategorizedEvent(`Recommending version: ${recommendedVersion}.`));

        const chosenVersion = (await vscode.window.showInputBox(
            {
                placeHolder: recommendedVersion,
                value: recommendedVersion,
                prompt: 'The .NET SDK version. You can use different formats: 5, 3.1, 7.0.3xx, 6.0.201, etc.',
            })) ?? recommendedVersion;

        globalEventStream.post(new UserManualInstallVersionChosen(`The user has chosen to install the .NET SDK version ${chosenVersion}.`));

        try
        {
            globalEventStream.post(new UserManualInstallRequested(`Starting to install the .NET SDK ${chosenVersion} via a user request.`));

            await vscode.commands.executeCommand('dotnet.showAcquisitionLog');
            const userCommandContext: IDotnetAcquireContext = { version: chosenVersion, requestingExtensionId: 'user', installType: 'global' };
            const acquireResult: IDotnetAcquireResult = await vscode.commands.executeCommand('dotnet.acquireGlobalSDK', userCommandContext);
            if (acquireResult && acquireResult?.dotnetPath)
            {
                globalEventStream.post(new UserManualInstallSuccess(`The .NET SDK ${chosenVersion} was successfully installed.`));
            }
        }
        catch (error)
        {
            globalEventStream.post(new UserManualInstallFailure((error as Error), `The .NET SDK ${chosenVersion} failed to install. Error: ${(error as Error).toString()}`));
            vscode.window.showErrorMessage((error as Error).toString());
        }
    });

    const dotnetAcquireStatusRegistration = vscode.commands.registerCommand(`${commandPrefix}.${commandKeys.acquireStatus}`, async (commandContext: IDotnetAcquireContext): Promise<IDotnetAcquireResult | undefined> =>
    {
        const pathResult = await callWithErrorHandling(async () =>
        {
            commandContext.mode ??= 'runtime' as DotnetInstallMode;
            commandContext.architecture ??= DotnetCoreAcquisitionWorker.defaultArchitecture();
            commandContext.installType ??= 'local' as DotnetInstallType;
            commandContext.requestingExtensionId ??= 'unspecified';
            const worker = getAcquisitionWorker();
            const workerContext = getAcquisitionWorkerContext(commandContext.mode, commandContext);

            globalEventStream.post(new DotnetAcquisitionStatusRequested(commandContext.version, commandContext.requestingExtensionId));

            // Caveat : acquireStatus expects only a major.minor, so fully specified versions won't be checked here

            const existingOfflinePath = await getExistingInstallOffline(worker, workerContext);
            if (existingOfflinePath)
            {
                return Promise.resolve(existingOfflinePath);
            }

            const runtimeVersionResolver = new VersionResolver(workerContext);
            const resolvedVersion = await runtimeVersionResolver.getFullVersion(commandContext.version, commandContext.mode);
            commandContext.version = resolvedVersion;
            const dotnetPath = await worker.acquireStatus(workerContext, commandContext.mode);
            return dotnetPath;
        }, getIssueContext(existingPathConfigWorker)(commandContext.errorConfiguration, 'acquireStatus'));
        return pathResult;
    });

    const dotnetAvailableInstallsRegistration = vscode.commands.registerCommand(`${commandPrefix}.${commandKeys.availableInstalls}`,
        async (commandContext: IDotnetSearchContext): Promise<IDotnetSearchResult[]> =>
        {
            if (commandContext.mode === undefined || commandContext.requestingExtensionId === undefined)
            {
                throw new EventCancellationError('BadContextualAvailbleInstallsError', `The dotnet.availableInstalls API request was missing either a mode or requestingExtensionId. Please provide this.`);
            }

            const pathWasProvided = (commandContext.dotnetExecutablePath ?? '') !== '';
            let dotnetExecutablePath = pathWasProvided ? commandContext.dotnetExecutablePath! : 'dotnet';

            const searchForInstalls = async (hostPath: string): Promise<IDotnetSearchResult[] | undefined> =>
                callWithErrorHandling(async () =>
                {
                    // Bad design: An acquire context is needed to setup the state, but don't want to untangle that in this change.
                    const fakeAcquireContext = {
                        version: 'notApplicable',
                        requestingExtensionId: commandContext.requestingExtensionId,
                        architecture: commandContext.architecture,
                        mode: commandContext.mode,
                        installType: 'local' as DotnetInstallType, // does not matter as we search based on the host path
                        errorConfiguration: commandContext.errorConfiguration
                    } as IDotnetAcquireContext;
                    const workerContext = getAcquisitionWorkerContext(commandContext.mode, fakeAcquireContext);

                    const dotnetResolver = new DotnetResolver(workerContext, utilContext);
                    const installsInListForm: IDotnetListInfo[] = await dotnetResolver.getDotnetInstalls(hostPath, commandContext.mode, commandContext.architecture);

                    return installsInListForm.map((installInfo: IDotnetListInfo) =>
                    {
                        return {
                            mode: installInfo.mode,
                            version: installInfo.version,
                            directory: installInfo.directory,
                            architecture: installInfo.architecture ?? DotnetCoreAcquisitionWorker.defaultArchitecture(),
                        } as IDotnetSearchResult;
                    });
                }, getIssueContext(existingPathConfigWorker)(commandContext?.errorConfiguration, commandKeys.availableInstalls));

            let installs = await searchForInstalls(dotnetExecutablePath);

            // When no host path is provided we default to a bare 'dotnet', which relies on the PATH. On some platforms
            // (notably macOS GUI launches, where /etc/paths.d is not honored by the extension host process) the host is
            // not on the PATH even though .NET is installed, so the search finds nothing on the first try. In that case,
            // reuse the shared dotnet.findPath logic, which locates the host independently of the PATH (e.g. via the
            // known install locations on disk), and retry the search with the discovered host path. This is opt-in via
            // fallbackToFindPathInstalls because findPath may return non system-level paths, so enabling it can change
            // which installs are returned; defaulting it off preserves the original behavior for existing callers.
            if ((installs?.length ?? 0) === 0 && !pathWasProvided && commandContext.fallbackToFindPathInstalls === true)
            {
                const findPathContext: IDotnetFindPathContext = {
                    acquireContext: {
                        // We only need *a* host that has installs of the requested mode; accept any version it reports.
                        version: '1.0',
                        requestingExtensionId: commandContext.requestingExtensionId,
                        architecture: commandContext.architecture ?? DotnetCoreAcquisitionWorker.defaultArchitecture(),
                        mode: commandContext.mode,
                        installType: 'global' as DotnetInstallType,
                        errorConfiguration: commandContext.errorConfiguration,
                    } as IDotnetAcquireContext,
                    versionSpecRequirement: 'greater_than_or_equal',
                };
                const foundHost = await vscode.commands.executeCommand<IDotnetAcquireResult | undefined>(`${commandPrefix}.${commandKeys.findPath}`, findPathContext);

                if (foundHost?.dotnetPath && foundHost.dotnetPath !== dotnetExecutablePath)
                {
                    dotnetExecutablePath = foundHost.dotnetPath;
                    installs = await searchForInstalls(dotnetExecutablePath);
                }
            }

            if ((installs?.length ?? 0) > 0)
            {
                await InstallTrackerSingleton.getInstance(globalEventStream, vsCodeContext.globalState).markInstallAsInUse(dotnetExecutablePath);
            }

            return installs ?? [];
        });

    const resetDataPublicRegistration = vscode.commands.registerCommand(`${commandPrefix}.${commandKeys.resetData}`, async () =>
    {
        const uninstallContext: IDotnetUninstallContext = {
            errorConfiguration: UninstallErrorConfiguration.DisplayAllErrorPopups,
        };
        return uninstallAll(uninstallContext);
    });

    const resetUpdateTimerInternalRegistration = vscode.commands.registerCommand(`${commandPrefix}.${commandKeys.resetUpdateTimerInternal}`, async () =>
    {
        await vsCodeContext.globalState.update('dotnet.latestUpdateDate', undefined);
        return vsCodeContext.globalState.get<Date>('dotnet.latestUpdateDate');
    });

    const dotnetUninstallPublicRegistration = vscode.commands.registerCommand(`${commandPrefix}.${commandKeys.uninstallPublic}`, async () =>
    {
        const existingInstalls: InstallRecord[] = await InstallTrackerSingleton.getInstance(globalEventStream, vsCodeContext.globalState).getExistingInstalls(directoryProviderFactory(
            'runtime', vsCodeContext.globalStoragePath));

        const menuItems = existingInstalls?.sort(
            function (x: InstallRecord, y: InstallRecord): number
            {
                if (x.dotnetInstall.installMode === y.dotnetInstall.installMode)
                {
                    return x.dotnetInstall.version.localeCompare(y.dotnetInstall.version);
                }
                return x.dotnetInstall.installMode.localeCompare(y.dotnetInstall.installMode);
            })?.map(install =>
            {
                return {
                    label: `.NET ${(install.dotnetInstall.installMode === 'sdk' ? 'SDK' : install.dotnetInstall.installMode === 'runtime' ? 'Runtime' : 'ASP.NET Core Runtime')} ${install.dotnetInstall.version}`,
                    description: `${install.dotnetInstall.architecture ?? ''} | ${install.dotnetInstall.isGlobal ? 'machine-wide' : 'vscode-local'}`,
                    detail: install.installingExtensions.some(x => x !== null) ? `Used by ${install.installingExtensions.join(', ')}` : ``,
                    iconPath: install.dotnetInstall.isGlobal ? new vscode.ThemeIcon('shield') : new vscode.ThemeIcon('trash'),
                    internalId: install.dotnetInstall.installId
                }
            });

        if ((menuItems?.length ?? 0) < 1)
        {
            vscode.window.showInformationMessage('No .NET installations were found to uninstall.');
            return;
        }

        const chosenVersion = await vscode.window.showQuickPick(menuItems, { placeHolder: 'Select a version to uninstall.' });

        if (chosenVersion)
        {
            const installRecord: InstallRecord = existingInstalls.find(install => install.dotnetInstall.installId === chosenVersion.internalId)!;

            if (!installRecord || !installRecord?.dotnetInstall?.version || !installRecord?.dotnetInstall?.installMode)
            {
                return;
            }

            const selectedInstall: DotnetInstall = installRecord.dotnetInstall;
            let canContinue = true;
            const uninstallWillBreakSomething = !(await InstallTrackerSingleton.getInstance(globalEventStream, vsCodeContext.globalState).installHasNoDependents(selectedInstall, directoryProviderFactory(
                'runtime', vsCodeContext.globalStoragePath), true));

            const yes = `Continue`;
            if (uninstallWillBreakSomething)
            {
                const brokenExtensions = installRecord.installingExtensions.some(x => x !== null) ? installRecord.installingExtensions.join(', ') : 'extensions such as C# or C# DevKit';
                const pick = await vscode.window.showWarningMessage(
                    `Uninstalling .NET ${selectedInstall.version} will likely cause ${brokenExtensions} to stop functioning properly. Do you still wish to continue?`, { modal: true }, yes);
                canContinue = pick === yes;
            }

            if (!canContinue)
            {
                return;
            }

            const commandContext: IDotnetAcquireContext =
            {
                version: selectedInstall.version,
                mode: selectedInstall.installMode,
                installType: selectedInstall.isGlobal ? 'global' : 'local',
                architecture: selectedInstall.architecture,
                requestingExtensionId: 'user'
            }

            outputChannelObserver.showOutput();
            return uninstall(commandContext, true);
        }
    });

    /**
     * @returns 0 on success. Error string if not.
     */
    const dotnetUninstallRegistration = vscode.commands.registerCommand(`${commandPrefix}.${commandKeys.uninstall}`, async (commandContext: IDotnetAcquireContext | undefined): Promise<string> =>
    {
        return uninstall(commandContext);
    });

    const dotnetForceUpdateRegistration = vscode.commands.registerCommand(`${commandPrefix}.forceUpdate`, async (commandContext: IDotnetAcquireContext): Promise<void> =>
    {
        return automaticUpdater.ManageInstalls(0).catch((e: any) => {});
    });

    /**
     * @param commandContext The context of the request to find the dotnet path.
     * We wrap an AcquisitionContext which must include the version, requestingExtensionId, architecture of .NET desired, and mode.
     * The architecture should be of the node format ('x64', 'x86', 'arm64', etc.)
     *
     * @returns the path to the dotnet executable as an IDotnetAcquireResult (or undefined), if one can be found. This should be the true path to the executable. undefined if none can be found.
     * Before version 2.2.2, the result could be a string, undefined, or an IDotnetAcquireResult. This was changed to be more consistent with the rest of the APIs.
     *
     * @remarks Priority Order for path lookup:
     * VSCode Setting -> PATH -> Realpath of PATH -> DOTNET_ROOT (Emulation DOTNET_ROOT if set first)
     *
     * This accounts for pmc installs, snap installs, bash configurations, and other non-standard installations such as homebrew.
     */
    const dotnetFindPathRegistration = vscode.commands.registerCommand(`${commandPrefix}.${commandKeys.findPath}`, async (commandContext: IDotnetFindPathContext): Promise<IDotnetAcquireResult | undefined> =>
    {
        const findPathResult = await callWithErrorHandling<Promise<IDotnetAcquireResult | undefined>>(async () =>
        {
            globalEventStream.post(new DotnetFindPathCommandInvoked(`The find path command was invoked.`, commandContext));

            if (!commandContext.acquireContext.mode || !commandContext.acquireContext.requestingExtensionId || !commandContext.acquireContext.version || !commandContext.acquireContext.architecture)
            {
                throw new EventCancellationError('BadContextualFindPathError', `The find path request was missing required information: a mode, version, architecture, and requestingExtensionId.`);
            }
            const requestedArchitecture = commandContext.acquireContext.architecture;

            globalEventStream.post(new DotnetFindPathLookupSetting(`Looking up vscode setting.`));
            const workerContext = getAcquisitionWorkerContext(commandContext.acquireContext.mode, commandContext.acquireContext);
            const existingPath = await resolveExistingPathIfExists(existingPathConfigWorker, commandContext.acquireContext, workerContext, utilContext, commandContext.versionSpecRequirement);

            // The setting is not intended to be used as the SDK, only the runtime for extensions to run on. Ex: PowerShell policy doesn't allow us to install the runtime, let users set the path manually.
            if (existingPath && commandContext.acquireContext.mode !== 'sdk')
            {
                // We don't need to validate the existing path as it gets validated + tracked in the lookup logic already.
                globalEventStream.post(new DotnetFindPathSettingFound(`Found vscode setting.`));
                void loggingObserver.flush();
                return existingPath;
            }

            const validator = new DotnetConditionValidator(workerContext, utilContext);
            const finder = new DotnetHostPathFinder(workerContext, utilContext);

            const dotnetOnShellSpawn = (await finder.findDotnetFastFromListOnly(requestedArchitecture)) ?? '';
            if (dotnetOnShellSpawn)
            {
                const validatedShellSpawn = await getPathIfValid(dotnetOnShellSpawn, validator, commandContext);
                if (validatedShellSpawn)
                {
                    void loggingObserver.flush();
                    return { dotnetPath: validatedShellSpawn };
                }
            }

            const dotnetsOnPATH = await finder.findRawPathEnvironmentSetting(true, requestedArchitecture);
            for (const dotnetPath of dotnetsOnPATH ?? [])
            {
                const validatedPATH = await getPathIfValid(dotnetPath, validator, commandContext);
                if (validatedPATH)
                {
                    void loggingObserver.flush();
                    return { dotnetPath: validatedPATH };
                }
            }

            const dotnetsOnRealPATH = await finder.findRealPathEnvironmentSetting(true, requestedArchitecture);
            for (const dotnetPath of dotnetsOnRealPATH ?? [])
            {
                const validatedRealPATH = await getPathIfValid(dotnetPath, validator, commandContext);
                if (validatedRealPATH)
                {
                    void loggingObserver.flush();
                    return { dotnetPath: validatedRealPATH };
                }
            }

            const dotnetOnROOT = await finder.findDotnetRootPath(commandContext.acquireContext.architecture);
            const validatedRoot = await getPathIfValid(dotnetOnROOT, validator, commandContext);
            if (validatedRoot)
            {
                void loggingObserver.flush();
                return { dotnetPath: validatedRoot };
            }

            if (commandContext.acquireContext.mode !== 'sdk' && !commandContext.disableLocalLookup)
            {
                const extensionManagedRuntimeRecordPaths = await finder.findExtensionManagedRuntimes();
                const filteredExtensionManagedRuntimeRecordPaths = validator.filterValidPaths(extensionManagedRuntimeRecordPaths, commandContext);
                for (const dotnetPath of filteredExtensionManagedRuntimeRecordPaths ?? [])
                {
                    const validatedExistingManagedPath = await getPathIfValid(dotnetPath.path, validator, commandContext);
                    if (validatedExistingManagedPath)
                    {
                        void loggingObserver.flush();
                        return { dotnetPath: dotnetPath.path };
                    }
                }
            }

            const dotnetOnHostfxrRecord = await finder.findHostInstallPaths(commandContext.acquireContext.architecture);
            for (const dotnetPath of dotnetOnHostfxrRecord ?? [])
            {
                const validatedHostfxr = await getPathIfValid(dotnetPath, validator, commandContext);
                if (validatedHostfxr && process.env.DOTNET_INSTALL_TOOL_SKIP_HOSTFXR !== 'true')
                {
                    void loggingObserver.flush();
                    return { dotnetPath: validatedHostfxr };
                }
            }

            void loggingObserver.flush();
            globalEventStream.post(new DotnetFindPathNoPathMetCondition(`Could not find a single host path that met the conditions.
existingPath : ${existingPath?.dotnetPath}
onPath : ${JSON.stringify(dotnetsOnPATH)}
onRealPath : ${JSON.stringify(dotnetsOnRealPATH)}
onRoot : ${dotnetOnROOT}
onHostfxrRecord : ${JSON.stringify(dotnetOnHostfxrRecord)}

Requirement:
${JSON.stringify(commandContext)}`));
            return undefined;
        }, getIssueContext(existingPathConfigWorker)(commandContext?.acquireContext?.errorConfiguration, commandKeys.findPath));

        return findPathResult;
    });

    async function getPathIfValid(candidatePath: string | undefined, validator: IDotnetConditionValidator, commandContext: IDotnetFindPathContext): Promise<string | undefined>
    {
        if (candidatePath)
        {
            const validated = await validator.dotnetMeetsRequirement(candidatePath, commandContext);
            if (validated)
            {
                globalEventStream.post(new DotnetFindPathMetCondition(`${candidatePath} met the conditions.`));
                await InstallTrackerSingleton.getInstance(globalEventStream, vsCodeContext.globalState).markInstallAsInUse(candidatePath);
                return candidatePath;
            }
        }

        return undefined;
    }

    async function uninstall(commandContext: IDotnetAcquireContext | undefined, force = false, onlyCheckLiveDependents = false): Promise<string>
    {
        let result = '1';

        // Create workerContext early if we have enough info (for error handling context)
        // Wrapped in try-catch to avoid unhandled exceptions if context creation fails
        let workerContext: IAcquisitionWorkerContext | undefined;
        try
        {
            workerContext = commandContext?.mode && commandContext?.requestingExtensionId
                ? getAcquisitionWorkerContext(commandContext.mode, commandContext)
                : undefined;
        }
        catch
        {
            // If context creation fails, continue without it - errors will still be handled
            workerContext = undefined;
        }

        await callWithErrorHandling(async () =>
        {
            if (!commandContext?.version || !commandContext?.installType || !commandContext?.mode || !commandContext?.requestingExtensionId)
            {
                const error = new EventCancellationError('InvalidUninstallRequest', `The caller ${commandContext?.requestingExtensionId} did not properly submit an uninstall request.
    Please include the mode, installType, version, and extensionId.`);
                globalEventStream.post(new InvalidUninstallRequest(error as Error));
                throw error;
            }
            else
            {
                const worker = getAcquisitionWorker();
                // Use the pre-created workerContext if available, otherwise create it
                const ctx = workerContext ?? getAcquisitionWorkerContext(commandContext.mode, commandContext);

                if (commandContext.installType === 'local' && !force && !(onlyCheckLiveDependents && commandContext.version.split('.').length > 1)) // if using force mode, we are also using the UI, which passes the fully specified version to uninstall only
                {
                    const versionResolver = new VersionResolver(ctx);
                    const resolvedVersion = await versionResolver.getFullVersion(commandContext.version, commandContext.mode);
                    commandContext.version = resolvedVersion;
                }

                const installationId = getInstallIdCustomArchitecture(commandContext.version, commandContext.architecture, commandContext.mode, commandContext.installType);
                const install = {
                    installId: installationId, version: commandContext.version, installMode: commandContext.mode, isGlobal: commandContext.installType === 'global',
                    architecture: commandContext.architecture ?? DotnetCoreAcquisitionWorker.defaultArchitecture()
                } as DotnetInstall;

                if (commandContext.installType === 'local')
                {
                    result = await worker.uninstallLocal(ctx, install, force, false, onlyCheckLiveDependents);
                }
                else
                {
                    const globalInstallerResolver = new GlobalInstallerResolver(ctx, commandContext.version);
                    result = await worker.uninstallGlobal(ctx, install, globalInstallerResolver, force);
                }

                // A non-zero (and non-empty) result code means the uninstall did not succeed. Throw from inside the
                // callWithErrorHandling callback so the failure goes through the standard error handling path
                // (failure event posting, telemetry, and popups) instead of being reported as a success, and is then
                // rethrown consistently when rethrowError is requested (e.g. for the LLM tools).
                if (result !== '0' && result !== '')
                {
                    throw new Error(`Uninstall of .NET ${commandContext.version} did not succeed (code ${result}). The uninstaller may have been cancelled, blocked by another install in progress, or require manual removal.`);
                }
            }
        }, getIssueContext(existingPathConfigWorker)(commandContext?.errorConfiguration, 'uninstall'), commandContext?.requestingExtensionId, workerContext, commandContext?.rethrowError);

        return result;
    }

    const dotnetUninstallAllRegistration = vscode.commands.registerCommand(`${commandPrefix}.${commandKeys.uninstallAll}`, async (commandContext: IDotnetUninstallContext | undefined) =>
    {
        return uninstallAll(commandContext);
    });

    async function uninstallAll(commandContext: IDotnetUninstallContext | undefined): Promise<number>
    {
        await callWithErrorHandling(async () =>
        {
            const mode = 'runtime' as DotnetInstallMode;
            const worker = getAcquisitionWorker();
            const installDirectoryProvider = directoryProviderFactory(mode, vsCodeContext.globalStoragePath);

            await worker.uninstallAll(globalEventStream, installDirectoryProvider.getStoragePath(), vsCodeContext.globalState);
        },
            getIssueContext(existingPathConfigWorker)(commandContext ? commandContext.errorConfiguration : undefined, 'uninstallAll')
        );

        return Promise.resolve(0);
    }

    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 () =>
        {
            if (os.platform() !== 'linux')
            {
                // We can't handle installing dependencies for anything other than Linux
                return;
            }

            // commandContext.arguments is either the dotnet process args (string[]) or a SpawnSync options object.
            // Use the 3-arg overload (empty args + options) for the options case so the two paths are distinct.
            const result = Array.isArray(commandContext.arguments)
                ? cp.spawnSync(commandContext.command, commandContext.arguments)
                : cp.spawnSync(commandContext.command, [], commandContext.arguments);
            const installer = new DotnetCoreDependencyInstaller();
            if (installer.signalIndicatesMissingLinuxDependencies(result.signal!))
            {
                globalEventStream.post(new DotnetAcquisitionMissingLinuxDependencies());
                await installer.promptLinuxDependencyInstall('Failed to run .NET runtime.');
            }
        }, getIssueContext(existingPathConfigWorker)(commandContext.errorConfiguration, 'ensureDependencies'));
    });

    const reportIssueRegistration = vscode.commands.registerCommand(`${commandPrefix}.${commandKeys.reportIssue}`, async () =>
    {
        const [url, issueBody] = formatIssueUrl(undefined, getIssueContext(existingPathConfigWorker)(AcquireErrorConfiguration.DisableErrorPopups, 'reportIssue'));
        await vscode.env.clipboard.writeText(issueBody);
        open(url).catch(() => {});
    });

    // Helper Functions
    async function resolveExistingPathIfExists(configResolver: ExtensionConfigurationWorker, commandContext: IDotnetAcquireContext,
        workerContext: IAcquisitionWorkerContext, utilityContext: IUtilityContext, requirement?: DotnetVersionSpecRequirement): Promise<IDotnetAcquireResult | null>
    {
        const existingPathResolver = new ExistingPathResolver(workerContext, utilityContext);

        const existingPath = await existingPathResolver.resolveExistingPath(configResolver.getAllPathConfigurationValues(), commandContext.requestingExtensionId, displayWorker, requirement);
        if (existingPath)
        {
            globalEventStream.post(new DotnetExistingPathResolutionCompleted(existingPath.dotnetPath));
            return new Promise((resolve) =>
            {
                resolve(existingPath);
            });
        }
        return new Promise((resolve) =>
        {
            resolve(null);
        });
    }

    const getAvailableVersions = async (commandContext: IDotnetListVersionsContext | undefined,
        customWebWorker: WebRequestWorkerSingleton | undefined, onRecommendationMode: boolean): Promise<IDotnetListVersionsResult | undefined> =>
    {
        const mode = 'sdk' as DotnetInstallMode;
        const workerContext = getVersionResolverContext(mode, 'global', commandContext?.errorConfiguration);
        const customVersionResolver = new VersionResolver(workerContext, customWebWorker);

        if (os.platform() !== 'linux' || !onRecommendationMode)
        {
            const versionsResult = await callWithErrorHandling(async () =>
            {
                return customVersionResolver.GetAvailableDotnetVersions(commandContext);
            }, getIssueContext(existingPathConfigWorker)(commandContext?.errorConfiguration, 'getAvailableVersions'));

            return versionsResult;
        }
        else
        {
            const linuxResolver = new LinuxVersionResolver(workerContext, utilContext);
            try
            {
                const suggestedVersion = await linuxResolver.getRecommendedDotnetVersion('sdk' as DotnetInstallMode);
                const osAgnosticVersionData = await getAvailableVersions(commandContext, customWebWorker, !onRecommendationMode);
                const resolvedSupportPhase = osAgnosticVersionData?.find((version: IDotnetVersion) =>
                    getMajorMinor(version.version, globalEventStream, workerContext) === getMajorMinor(suggestedVersion, globalEventStream, workerContext))?.supportPhase ?? 'active';
                // Assumption : The newest version is 'active' support, but we can't guarantee that.
                // If the linux version is too old it will eventually support no active versions of .NET, which would cause a failure.
                // The best we can give it is the newest working version, which is the most likely to be supported, and mark it as active so we can use it.

                return [
                    {
                        version: suggestedVersion, channelVersion: `${getMajorMinor(suggestedVersion, globalEventStream, workerContext)}`,
                        supportStatus: Number(getMajor(suggestedVersion, globalEventStream, workerContext)) % 2 === 0 ? 'lts' : 'sts',
                        supportPhase: resolvedSupportPhase
                    }
                ];
            }
            catch (error: any)
            {
                return [];
            }
        }
    }

    /**
     * @returns A 'worker' context object that can be used for when there actually isn't any acquisition happening.
     * Eventually the version resolver and web request worker should be decoupled from the context object, ...
     * so we don't need to do this, but not doing this right now.
     */
    function getVersionResolverContext(mode: DotnetInstallMode, typeOfInstall: DotnetInstallType, errorsConfiguration?: ErrorConfiguration): IAcquisitionWorkerContext
    {
        return getAcquisitionWorkerContext(mode,
            {
                requestingExtensionId: 'notProvided',
                installType: typeOfInstall,
                version: 'notAnAcquisitionRequest',
                errorConfiguration: errorsConfiguration,
                architecture: DotnetCoreAcquisitionWorker.defaultArchitecture(),
                mode
            } as IDotnetAcquireContext
        )
    }

    function getAcquisitionWorkerContext(mode: DotnetInstallMode, acquiringContext: IDotnetAcquireContext): IAcquisitionWorkerContext
    {
        const taggedEventStream = new EventStreamTaggingDecorator(globalEventStream);
        return {
            storagePath: vsCodeContext.globalStoragePath,
            extensionState: vsCodeContext.globalState,
            eventStream: taggedEventStream,
            installationValidator: new InstallationValidator(taggedEventStream),
            timeoutSeconds: resolvedTimeoutSeconds,
            acquisitionContext: acquiringContext,
            installDirectoryProvider: directoryProviderFactory(mode, vsCodeContext.globalStoragePath),
            proxyUrl: proxyLink,
            isExtensionTelemetryInitiallyEnabled: isExtensionTelemetryEnabled,
            allowInvalidPathSetting: allowInvalidPathSetting ?? false
        }
    }

    function getAcquisitionWorker(): DotnetCoreAcquisitionWorker
    {
        return new DotnetCoreAcquisitionWorker(utilContext, vsCodeExtensionContext);
    }

    function getIssueContext(configResolver: ExtensionConfigurationWorker)
    {
        return (errorConfiguration: ErrorConfiguration | undefined, commandName: string, version?: string) =>
        {
            return {
                logger: loggingObserver,
                errorConfiguration: errorConfiguration || AcquireErrorConfiguration.DisplayAllErrorPopups,
                displayWorker,
                extensionConfigWorker: configResolver,
                eventStream: globalEventStream,
                commandName,
                version,
                moreInfoUrl,
                timeoutInfoUrl: `${moreInfoUrl}#install-script-timeouts`
            } as IIssueContext;
        };
    }

    async function getExistingInstallIfOffline(worker: DotnetCoreAcquisitionWorker, workerContext: IAcquisitionWorkerContext): Promise<IDotnetAcquireResult | null>
    {
        const isOffline = !(await WebRequestWorkerSingleton.getInstance().isOnline(timeoutValue ?? defaultTimeoutValue, globalEventStream));
        if (isOffline)
        {
            return getExistingInstallOffline(worker, workerContext);
        }
        return null;
    }

    async function getExistingInstallOffline(worker: DotnetCoreAcquisitionWorker, workerContext: IAcquisitionWorkerContext): Promise<IDotnetAcquireResult | null>
    {
        workerContext.acquisitionContext.architecture ??= DotnetCoreAcquisitionWorker.defaultArchitecture();
        const existingOfflinePath = await worker.getSimilarExistingInstall(workerContext);
        if (existingOfflinePath?.dotnetPath)
        {
            return Promise.resolve(existingOfflinePath);
        }
        else
        {
            if (!(await WebRequestWorkerSingleton.getInstance().isOnline(timeoutValue ?? defaultTimeoutValue, globalEventStream)))
            {
                globalEventStream.post(new DotnetOfflineWarning(`It looks like you may be offline (can you connect to www.microsoft.com?) and have no compatible installations of .NET ${workerContext.acquisitionContext.version} for ${workerContext.acquisitionContext.requestingExtensionId ?? 'user'}.
Installation will timeout in ${timeoutValue} seconds.`))
            }
        }

        return null;
    }

    // Preemptively install .NET for extensions who tell us to in their package.json
    const jsonInstaller = new JsonInstaller(globalEventStream, vsCodeExtensionContext);

    // Store references for deactivate()
    extensionEventStream = globalEventStream;
    extensionGlobalState = vsCodeContext.globalState;

    // Register Language Model Tools for AI agent integration (GitHub Copilot, etc.)
    const enableLanguageModelTools = extensionConfiguration.get<boolean>(configKeys.enableLanguageModelTools) ?? true;

    if (enableLanguageModelTools)
    {
        try
        {
            registerLanguageModelTools(vsCodeContext, globalEventStream);
        } catch (e)
        {
            // Language Model Tools API may not be available in older VS Code versions
            // Log telemetry for the failure but continue - extension works without AI tool integration
            const error = e instanceof Error ? e : new Error(String(e));
            globalEventStream.post(new LanguageModelToolsRegistrationError(error));
        }
    }

    // Exposing API Endpoints
    vsCodeContext.subscriptions.push(
        dotnetAcquireRegistration,
        dotnetAcquireStatusRegistration,
        dotnetAcquireGlobalSDKRegistration,
        dotnetAvailableInstallsRegistration,
        acquireGlobalSDKPublicRegistration,
        dotnetFindPathRegistration,
        dotnetListVersionsRegistration,
        dotnetRecommendedVersionRegistration,
        dotnetUninstallRegistration,
        dotnetUninstallPublicRegistration,
        dotnetUninstallAllRegistration,
        dotnetForceUpdateRegistration,
        showOutputChannelRegistration,
        getAcquisitionLogRegistration,
        ensureDependenciesRegistration,
        reportIssueRegistration,
        resetUpdateTimerInternalRegistration,
        ...eventStreamObservers);

    if (showResetDataCommand)
    {
        vsCodeContext.subscriptions.push(resetDataPublicRegistration);
    }
}

export function ReEnableActivationForManualActivation()
{
    disableActivationUnderTest = false;
}

export async function deactivate(): Promise<void>
{
    if (extensionEventStream && extensionGlobalState)
    {
        const tracker = InstallTrackerSingleton.getInstance(extensionEventStream, extensionGlobalState);
        await tracker.pruneStaleSessions();
        await tracker.removeCurrentSession();
    }
}