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 path from 'path';
import * as vscode from 'vscode';
// import * as runtimeExtension from 'vscode-dotnet-runtime'; // comment this out when packing the extension
import
{
    DotnetInstallMode,
    DotnetVersionSpecRequirement,
    IDotnetAcquireContext,
    IDotnetAcquireResult,
    IDotnetEnsureDependenciesContext,
    IDotnetFindPathContext,
    IDotnetListVersionsResult,
    IDotnetLogResult,
} from 'vscode-dotnet-runtime-library';

function parseEnsureDependenciesArguments(input: string): string[]
{
    const trimmed = input.trim();
    if (trimmed.startsWith('['))
    {
        const parsed = JSON.parse(trimmed);
        if (!Array.isArray(parsed) || parsed.some(arg => typeof arg !== 'string'))
        {
            throw new Error('Custom arguments JSON must be an array of strings.');
        }
        return parsed;
    }

    return trimmed.length === 0 ? [] : trimmed.split(/\s+/);
}

export function activate(context: vscode.ExtensionContext)
{

    // --------------------------------------------------------------------------

    /*

    NOTE: This sample should technically have the following in its package.json:

    "extensionDependencies": [
        "ms-dotnettools.vscode-dotnet-runtime",
    ]

    This would enable the sample to require the vscode-dotnet-runtime extension
    */

    const requestingExtensionId = 'ms-dotnettools.sample-extension';
    // runtimeExtension.activate(context); // comment this out when packing the extension


    // --------------------------------------------------------------------------

    // -------------------runtime extension registrations------------------------

    const sampleHelloWorldRegistration = vscode.commands.registerCommand('sample.helloworld', async () =>
    {
        try
        {
            await vscode.commands.executeCommand('dotnet.showAcquisitionLog');

            // Console app requires .NET 10.
            const commandRes = await vscode.commands.executeCommand<IDotnetAcquireResult>('dotnet.acquire', { version: '10.0', requestingExtensionId });
            const dotnetPath = commandRes!.dotnetPath;
            if (!dotnetPath)
            {
                throw new Error('Could not resolve the dotnet path!');
            }

            const sampleExtension = vscode.extensions.getExtension('ms-dotnettools.sample-extension');
            if (!sampleExtension)
            {
                throw new Error('Could not find sample extension.');
            }
            const helloWorldLocation = path.join(sampleExtension.extensionPath, 'HelloWorldConsoleApp', 'HelloWorldConsoleApp.dll');
            const helloWorldArgs = [helloWorldLocation];

            // This will install any missing Linux dependencies.
            await vscode.commands.executeCommand('dotnet.ensureDotnetDependencies', { command: dotnetPath, arguments: helloWorldArgs });

            const result = cp.spawnSync(dotnetPath, helloWorldArgs);
            const stderr = result?.stderr?.toString();
            if ((stderr?.length ?? 0) > 0)
            {
                vscode.window.showErrorMessage(`Failed to run Hello World:
${stderr}`);
                return;
            }

            const appOutput = result?.stdout?.toString();
            vscode.window.showInformationMessage(`.NET Output: ${appOutput}`);
        }
        catch (error)
        {
            vscode.window.showErrorMessage((error as Error).toString());
        }
    });

    async function callAcquireAPI(version: string | undefined, installMode: DotnetInstallMode | undefined, forceUpdates = true)
    {
        if (!version)
        {
            version = await vscode.window.showInputBox({
                placeHolder: '3.1',
                value: '3.1',
                prompt: '.NET version, i.e. 3.1',
            });
        }

        try
        {
            await vscode.commands.executeCommand('dotnet.showAcquisitionLog');
            await vscode.commands.executeCommand('dotnet.acquire', { version, requestingExtensionId, mode: installMode, forceUpdate: forceUpdates });
        }
        catch (error)
        {
            vscode.window.showErrorMessage((error as Error).toString());
        }
    }

    const sampleAcquireRegistration = vscode.commands.registerCommand('sample.dotnet.acquire', async (version: string | undefined) =>
    {
        await callAcquireAPI(version, undefined);
    });

    const sampleAcquireASPNETRegistration = vscode.commands.registerCommand('sample.dotnet.acquireASPNET', async (version: string | undefined) =>
    {
        await callAcquireAPI(version, 'aspnetcore');
    });

    const sampleAcquireNoForceRegistration = vscode.commands.registerCommand('sample.dotnet.acquireNoForce', async (version: string | undefined) =>
    {
        const mode = await vscode.window.showInputBox({
            placeHolder: 'runtime',
            value: 'runtime',
            prompt: '.NET mode to acquire, e.g. runtime or aspnetcore',
        });

        await callAcquireAPI(undefined, mode as DotnetInstallMode, false);
    });

    const sampleAcquireStatusRegistration = vscode.commands.registerCommand('sample.dotnet.acquireStatus', async (version: string | undefined) =>
    {
        if (!version)
        {
            version = await vscode.window.showInputBox({
                placeHolder: '3.1',
                value: '3.1',
                prompt: '.NET version, i.e. 3.1',
            });
        }

        try
        {
            await vscode.commands.executeCommand('dotnet.showAcquisitionLog');
            const status = await vscode.commands.executeCommand<IDotnetAcquireResult>('dotnet.acquireStatus', { version, requestingExtensionId });
            vscode.window.showInformationMessage(status === undefined ? '.NET is not installed' : `.NET version ${version} installed at ${status.dotnetPath}`);
        }
        catch (error)
        {
            vscode.window.showErrorMessage((error as Error).toString());
        }
    });

    const sampleDotnetUninstallAllRegistration = vscode.commands.registerCommand('sample.dotnet.uninstallAll', async () =>
    {
        try
        {
            await vscode.commands.executeCommand('dotnet.uninstallAll');
            vscode.window.showInformationMessage('.NET runtimes uninstalled.');
        }
        catch (error)
        {
            vscode.window.showErrorMessage((error as Error).toString());
        }
    });

    const sampleResetUpdateSuccessTime = vscode.commands.registerCommand('sample.dotnet.resetUpdateTimer', async () =>
    {
        try
        {
            const resetResult = await vscode.commands.executeCommand<Date | undefined>('dotnet._resetUpdateTimer');
            const resetDisplay = resetResult ? new Date(resetResult).toString() : 'undefined';
            vscode.window.showInformationMessage(`.NET update timer reset to: ${resetDisplay}`);
        }
        catch (error)
        {
            vscode.window.showErrorMessage((error as Error).toString());
        }
    });

    async function acquireConcurrent(versions: [string, string, string], installMode?: DotnetInstallMode)
    {
        try
        {
            vscode.commands.executeCommand('dotnet.showAcquisitionLog');
            const promises = [
                vscode.commands.executeCommand('dotnet.acquire', { version: versions[0], requestingExtensionId, mode: installMode }),
                vscode.commands.executeCommand('dotnet.acquire', { version: versions[1], requestingExtensionId, mode: installMode }),
                vscode.commands.executeCommand('dotnet.acquire', { version: versions[2], requestingExtensionId, mode: installMode })];

            for (const promise of promises)
            {
                // Await here so we can detect errors
                await promise;
            }
        }
        catch (error)
        {
            vscode.window.showErrorMessage((error as Error).toString());
        }
    }

    const sampleConcurrentTest = vscode.commands.registerCommand('sample.dotnet.concurrentTest', async () =>
    {
        await acquireConcurrent(['8.0', '9.0', '10.0'], 'runtime');
    });

    const sampleConcurrentASPNETTest = vscode.commands.registerCommand('sample.dotnet.concurrentASPNETTest', async () =>
    {
        acquireConcurrent(['8.0', '9.0', '10.0'], 'runtime') // start this so we test concurrent types of runtime installs
        await acquireConcurrent(['8.0', '9.0', '10.0'], 'aspnetcore');
    });

    const sampleShowAcquisitionLogRegistration = vscode.commands.registerCommand('sample.dotnet.showAcquisitionLog', async () =>
    {
        try
        {
            await vscode.commands.executeCommand('dotnet.showAcquisitionLog');
        }
        catch (error)
        {
            vscode.window.showErrorMessage((error as Error).toString());
        }
    });

    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 sampleEnsureDependenciesRegistration = vscode.commands.registerCommand('sample.dotnet.ensureDependencies', async () =>
    {
        const dotnetPath = await vscode.window.showInputBox({
            placeHolder: process.platform === 'win32' ? 'C:\\Program Files\\dotnet\\dotnet.exe' : '/usr/bin/dotnet',
            value: 'dotnet',
            prompt: 'The dotnet command or executable path to run.',
        });

        if (!dotnetPath)
        {
            return;
        }

        const argumentMode = await vscode.window.showQuickPick(['DLL path', 'Custom arguments'], {
            placeHolder: 'Choose the argument shape to pass to dotnet.ensureDotnetDependencies.'
        });

        if (!argumentMode)
        {
            return;
        }

        let args: string[];
        if (argumentMode === 'DLL path')
        {
            const dllPath = await vscode.window.showInputBox({
                placeHolder: '/path/to/LanguageServer.dll',
                prompt: 'The DLL path to pass as the single dotnet argument.',
            });

            if (!dllPath)
            {
                return;
            }
            args = [dllPath];
        }
        else
        {
            const customArgs = await vscode.window.showInputBox({
                placeHolder: '--info or ["/path/to/app.dll", "--flag"]',
                value: '--info',
                prompt: 'Arguments to pass to dotnet. Use JSON array syntax if an argument contains spaces.',
            });

            if (customArgs === undefined)
            {
                return;
            }
            args = parseEnsureDependenciesArguments(customArgs);
        }

        try
        {
            await vscode.commands.executeCommand('dotnet.showAcquisitionLog');
            const commandContext: IDotnetEnsureDependenciesContext = { command: dotnetPath, arguments: args };
            await vscode.commands.executeCommand('dotnet.ensureDotnetDependencies', commandContext);
            vscode.window.showInformationMessage(`dotnet.ensureDotnetDependencies completed for: ${dotnetPath} ${args.join(' ')}`);
        }
        catch (error)
        {
            vscode.window.showErrorMessage((error as Error).toString());
        }
    });

    const sampleGlobalSDKFromRuntimeRegistration = vscode.commands.registerCommand('sample.dotnet.acquireGlobalSDK', async (version: string | undefined) =>
    {
        if (!version)
        {
            version = await vscode.window.showInputBox({
                placeHolder: '7.0.103',
                value: '7.0.103',
                prompt: 'The .NET SDK version. You can use different formats: 5, 3.1, 7.0.3xx, 6.0.201, etc.',
            });
        }

        if (!version)
        {
            return;
        }

        try
        {
            await vscode.commands.executeCommand('dotnet.showAcquisitionLog');
            let commandContext: IDotnetAcquireContext = { version: version, requestingExtensionId: requestingExtensionId, installType: 'global' };
            await vscode.commands.executeCommand('dotnet.acquireGlobalSDK', commandContext);
        }
        catch (error)
        {
            vscode.window.showErrorMessage((error as Error).toString());
        }
    });

    const sampleFindPathRegistration = vscode.commands.registerCommand('sample.dotnet.findPath', async () =>
    {
        const version = await vscode.window.showInputBox(
            {
                placeHolder: '8.0',
                value: '8.0',
                prompt: 'The .NET runtime version.',
            });

        let arch = await vscode.window.showInputBox({
            placeHolder: 'x64',
            value: 'x64',
            prompt: 'The .NET runtime architecture.',
        });

        arch = arch?.toLowerCase();

        let searchMode = await vscode.window.showInputBox({
            placeHolder: 'runtime',
            value: 'runtime',
            prompt: 'look for an sdk, runtime, aspnetcore runtime, etc',
        });

        searchMode = searchMode?.toLowerCase() ?? 'runtime';

        let requirement = await vscode.window.showInputBox({
            placeHolder: 'greater_than_or_equal',
            value: 'greater_than_or_equal',
            prompt: 'The condition to search for a requirement.',
        });

        requirement = requirement?.toLowerCase();

        let commandContext: IDotnetFindPathContext = {
            acquireContext: { version: version, requestingExtensionId: requestingExtensionId, architecture: arch, mode: searchMode } as IDotnetAcquireContext,
            versionSpecRequirement: requirement as DotnetVersionSpecRequirement
        };

        const result = await vscode.commands.executeCommand('dotnet.findPath', commandContext);

        vscode.window.showInformationMessage(`.NET Path Discovered\n
${JSON.stringify(result) ?? 'undefined'}`);
    });

    const sampleAvailableInstallsRegistration = vscode.commands.registerCommand('sample.dotnet.availableInstalls', async (version: string | undefined) =>
    {
        let dotnetPath = await vscode.window.showInputBox({
            placeHolder: 'undefined',
            value: 'undefined',
            prompt: 'The .NET Host Path to Scan.',
        });

        dotnetPath = dotnetPath === 'undefined' ? undefined : dotnetPath;

        let arch = await vscode.window.showInputBox({
            placeHolder: 'x64',
            value: 'x64',
            prompt: 'The .NET runtime architecture.',
        });

        arch = arch?.toLowerCase();

        let searchMode = await vscode.window.showInputBox({
            placeHolder: 'runtime',
            value: 'runtime',
            prompt: 'look for an sdk, runtime, aspnetcore runtime, etc',
        });

        try
        {
            const result = await vscode.commands.executeCommand<IDotnetAcquireResult>('dotnet.availableInstalls', { architecture: arch, requestingExtensionId: requestingExtensionId, mode: searchMode, dotnetExecutablePath: dotnetPath });
            vscode.window.showInformationMessage(`.NET Discovered:\n
${JSON.stringify(result) ?? 'undefined'}`);
        }
        catch (error)
        {
            vscode.window.showErrorMessage((error as Error).toString());
        }
    });

    context.subscriptions.push(
        sampleHelloWorldRegistration,
        sampleAcquireRegistration,
        sampleAcquireASPNETRegistration,
        sampleAcquireStatusRegistration,
        sampleDotnetUninstallAllRegistration,
        sampleConcurrentTest,
        sampleConcurrentASPNETTest,
        sampleShowAcquisitionLogRegistration,
        sampleGetAcquisitionLogRegistration,
        sampleEnsureDependenciesRegistration,
        sampleFindPathRegistration,
        sampleAvailableInstallsRegistration
    );

    // --------------------------------------------------------------------------

    // ---------------------sdk extension registrations--------------------------

    const sampleSDKAcquireRegistration = vscode.commands.registerCommand('sample.dotnet-sdk.acquire', async (version: string | undefined) =>
    {
        if (!version)
        {
            version = await vscode.window.showInputBox({
                placeHolder: '5.0',
                value: '5.0',
                prompt: '.NET SDK version, i.e. 5.0',
            });
        }

        try
        {
            await vscode.commands.executeCommand('dotnet-sdk.showAcquisitionLog');
            await vscode.commands.executeCommand('dotnet-sdk.acquire', { version, requestingExtensionId });
        }
        catch (error)
        {
            vscode.window.showErrorMessage((error as Error).toString());
        }
    });

    const sampleSDKGlobalAcquireRegistration = vscode.commands.registerCommand('sample.dotnet-sdk.acquireGlobal', async (version: string | undefined) =>
    {
        if (!version)
        {
            version = await vscode.window.showInputBox({
                placeHolder: '7.0.103',
                value: '7.0.103',
                prompt: 'The .NET SDK version. You can use different formats: 5, 3.1, 7.0.3xx, 6.0.201, etc.',
            });
        }

        if (!version)
        {
            return;
        }

        try
        {
            await vscode.commands.executeCommand('dotnet-sdk.showAcquisitionLog');
            let commandContext: IDotnetAcquireContext = { version: version, requestingExtensionId: requestingExtensionId, installType: 'global' };
            await vscode.commands.executeCommand('dotnet-sdk.acquire', commandContext);
        }
        catch (error)
        {
            vscode.window.showErrorMessage((error as Error).toString());
        }
    });

    const sampleSDKAcquireStatusRegistration = vscode.commands.registerCommand('sample.dotnet-sdk.acquireStatus', async (version: string | undefined) =>
    {
        if (!version)
        {
            version = await vscode.window.showInputBox({
                placeHolder: '5.0',
                value: '5.0',
                prompt: '.NET SDK version, i.e. 5.0',
            });
        }

        try
        {
            await vscode.commands.executeCommand('dotnet-sdk.showAcquisitionLog');
            const status = await vscode.commands.executeCommand<IDotnetAcquireResult>('dotnet-sdk.acquireStatus', { version, requestingExtensionId });
            vscode.window.showInformationMessage(status === undefined ? '.NET is not installed' : `.NET version ${version} installed at ${status.dotnetPath}`);
        }
        catch (error)
        {
            vscode.window.showErrorMessage((error as Error).toString());
        }
    });

    const sampleSDKlistVersions = vscode.commands.registerCommand('sample.dotnet-sdk.listVersions', async (getRuntimes: boolean) =>
    {
        if (!getRuntimes)
        {
            getRuntimes = JSON.parse(await vscode.window.showInputBox({
                placeHolder: 'false',
                value: 'false',
                prompt: 'Acquire Runtimes? Use `true` if so, else, give `false`.',
            }) ?? 'false');
        }

        try
        {
            const result: IDotnetListVersionsResult | undefined = await vscode.commands.executeCommand('dotnet-sdk.listVersions', { listRuntimes: getRuntimes });
            vscode.window.showInformationMessage(`Available ${getRuntimes == false ? 'SDKS' : 'Runtimes'}: ${result?.map((x: any) => x.version).join(", ")}`);
        }
        catch (error)
        {
            vscode.window.showErrorMessage((error as Error).toString());
        }
    });

    const sampleSDKrecommendedVersion = vscode.commands.registerCommand('sample.dotnet-sdk.recommendedVersion', async (getRuntimes: boolean) =>
    {
        try
        {
            const result: IDotnetListVersionsResult | undefined = await vscode.commands.executeCommand('dotnet.recommendedVersion', { listRuntimes: getRuntimes });
            vscode.window.showInformationMessage(`Recommended SDK Version to Install: ${result?.[0]?.version}`);
        }
        catch (error)
        {
            vscode.window.showErrorMessage((error as Error).toString());
        }
    });

    const sampleSDKDotnetUninstallAllRegistration = vscode.commands.registerCommand('sample.dotnet-sdk.uninstallAll', async () =>
    {
        try
        {
            await vscode.commands.executeCommand('dotnet-sdk.uninstallAll');
            vscode.window.showInformationMessage('.NET SDKs uninstalled.');
        }
        catch (error)
        {
            vscode.window.showErrorMessage((error as Error).toString());
        }
    });

    const sampleSDKShowAcquisitionLogRegistration = vscode.commands.registerCommand('sample.dotnet-sdk.showAcquisitionLog', async () =>
    {
        try
        {
            await vscode.commands.executeCommand('dotnet-sdk.showAcquisitionLog');
        }
        catch (error)
        {
            vscode.window.showErrorMessage((error as Error).toString());
        }
    });

    const sampleForceUpdateRegistration = vscode.commands.registerCommand('sample.dotnet.forceUpdate', async () =>
    {
        try
        {
            // Call the forceUpdate command from the runtime extension
            await vscode.commands.executeCommand('dotnet.forceUpdate', { requestingExtensionId });
        }
        catch (error)
        {
            vscode.window.showErrorMessage((error as Error).toString());
        }
    });

    context.subscriptions.push(
        sampleSDKAcquireRegistration,
        sampleSDKGlobalAcquireRegistration,
        sampleSDKAcquireStatusRegistration,
        sampleSDKlistVersions,
        sampleSDKrecommendedVersion,
        sampleSDKDotnetUninstallAllRegistration,
        sampleSDKShowAcquisitionLogRegistration,
        sampleForceUpdateRegistration,
        sampleGlobalSDKFromRuntimeRegistration,
        sampleResetUpdateSuccessTime,
        sampleAcquireNoForceRegistration);
}