constructor() {
        const serverUrl: string = tl.getVariable('System.TeamFoundationCollectionUri');
        const serverCreds: string = tl.getEndpointAuthorizationParameter('SYSTEMVSSCONNECTION', 'ACCESSTOKEN', false);
        const authHandler = getPersonalAccessTokenHandler(serverCreds);

        const proxy = tl.getHttpProxyConfiguration();
        const options = proxy ? { proxy, ignoreSslError: true } : undefined;

        this.serverConnection = new WebApi(serverUrl, authHandler, options);
    }

export function getWebApiWithProxy(serviceUri: string, accessToken?: string): vsts.WebApi {
    if (!accessToken) {
        accessToken = getSystemAccessToken();
    }

    const credentialHandler = vsts.getBasicHandler('vsts', accessToken);
    const options: IRequestOptions = {
        proxy: tl.getHttpProxyConfiguration(serviceUri)
    };
    return new vsts.WebApi(serviceUri, credentialHandler, options);
}

 public static async installNuGet(version: string) {
     try {
         const proxy: tl.ProxyConfiguration = tl.getHttpProxyConfiguration();
         if (proxy) {
             console.log(tl.loc("InstallingNuGetVersion", version));
             await nuGetGetter.getNuGet(version, false, true);
             NuGetInstaller.setProxy(proxy);
         }
     }
     catch (error) {
         throw tl.loc("FailureWhileInstallingNuGetVersion", version, error.message);
     }
 }

    // make a request to the endpoint uri, and take a look at the response header to
    // determine whether this is our service, or an external service.
    private static async isEndpointInternal(endpointUri: string): Promise<boolean> {
        let requestOptions: IRequestOptions;
        try {
            const proxy = tl.getHttpProxyConfiguration();
            requestOptions = proxy ? { proxy } : {};
        } catch (error) {
            tl.debug('unable to determine proxy configuration: ' + error);
            requestOptions = {};
        }

        const headers: IHeaders = {};
        headers['X-TFS-FedAuthRedirect'] = 'Suppress';

        const endpointClient = new HttpClient(tl.getVariable('AZURE_HTTP_USER_AGENT'), null, requestOptions);
        try {
            const resp = await endpointClient.get(endpointUri, headers);
            return resp.message.rawHeaders !== null && resp.message.rawHeaders.some( t => t.toLowerCase().indexOf('x-tfs') >= 0 || t.toLowerCase().indexOf('x-vss') >= 0 );
        } catch (error) {
            tl.debug(error);
            return false;
        }
    }

async function run() {
    try {
        //
        // Version is optional.  If supplied, install / use from the tool cache
        // If not supplied then task is still used to setup proxy, auth, etc...
        //
        const version = taskLib.getInput('version', false);
        if (version) {
            const checkLatest: boolean = taskLib.getBoolInput('checkLatest', false);

            // TODO: installer doesn't support proxy
            await installer.getNode(version, checkLatest);
        }

        const proxyCfg: taskLib.ProxyConfiguration = taskLib.getHttpProxyConfiguration();
        if (proxyCfg) {
            proxyutil.setCurlProxySettings(proxyCfg);
        }
    }
    catch (error) {
        taskLib.setResult(taskLib.TaskResult.Failed, error.message);
    }
}