artifact-engine 1.2.0 → 1.3.0

package/Providers/typed-rest-client/handlers/basiccreds.js

@@ -1,20 +1,23 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.BasicCredentialHandler = void 0;
-class BasicCredentialHandler {
-    constructor(username, password) {
-        this.username = username;
-        this.password = password;
-    }
-    prepareRequest(options) {
-        options.headers['Authorization'] = 'Basic ' + new Buffer(this.username + ':' + this.password).toString('base64');
-        options.headers['X-TFS-FedAuthRedirect'] = 'Suppress';
-    }
-    canHandleAuthentication(res) {
-        return false;
-    }
-    handleAuthentication(httpClient, protocol, options, objs, finalCallback) {
-    }
-}
-exports.BasicCredentialHandler = BasicCredentialHandler;
-//# sourceMappingURL=basiccreds.js.map
+"use strict";
+// Copyright (c) Microsoft. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information.
+Object.defineProperty(exports, "__esModule", { value: true });
+class BasicCredentialHandler {
+    constructor(username, password) {
+        this.username = username;
+        this.password = password;
+    }
+    // currently implements pre-authorization
+    // TODO: support preAuth = false where it hooks on 401
+    prepareRequest(options) {
+        options.headers['Authorization'] = 'Basic ' + new Buffer(this.username + ':' + this.password).toString('base64');
+        options.headers['X-TFS-FedAuthRedirect'] = 'Suppress';
+    }
+    // This handler cannot handle 401
+    canHandleAuthentication(res) {
+        return false;
+    }
+    handleAuthentication(httpClient, protocol, options, objs, finalCallback) {
+    }
+}
+exports.BasicCredentialHandler = BasicCredentialHandler;

package/Providers/typed-rest-client/handlers/bearertoken.d.ts

@@ -1,8 +1,8 @@
-import ifm = require('../Interfaces');
-export declare class BearerCredentialHandler implements ifm.IRequestHandler {
-    token: string;
-    constructor(token: string);
-    prepareRequest(options: any): void;
-    canHandleAuthentication(res: ifm.IHttpResponse): boolean;
-    handleAuthentication(httpClient: any, protocol: any, options: any, objs: any, finalCallback: any): void;
-}
+import ifm = require('../Interfaces');
+export declare class BearerCredentialHandler implements ifm.IRequestHandler {
+    token: string;
+    constructor(token: string);
+    prepareRequest(options: any): void;
+    canHandleAuthentication(res: ifm.IHttpResponse): boolean;
+    handleAuthentication(httpClient: any, protocol: any, options: any, objs: any, finalCallback: any): void;
+}

package/Providers/typed-rest-client/handlers/bearertoken.js

@@ -1,19 +1,22 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.BearerCredentialHandler = void 0;
-class BearerCredentialHandler {
-    constructor(token) {
-        this.token = token;
-    }
-    prepareRequest(options) {
-        options.headers['Authorization'] = 'Bearer ' + this.token;
-        options.headers['X-TFS-FedAuthRedirect'] = 'Suppress';
-    }
-    canHandleAuthentication(res) {
-        return false;
-    }
-    handleAuthentication(httpClient, protocol, options, objs, finalCallback) {
-    }
-}
-exports.BearerCredentialHandler = BearerCredentialHandler;
-//# sourceMappingURL=bearertoken.js.map
+"use strict";
+// Copyright (c) Microsoft. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information.
+Object.defineProperty(exports, "__esModule", { value: true });
+class BearerCredentialHandler {
+    constructor(token) {
+        this.token = token;
+    }
+    // currently implements pre-authorization
+    // TODO: support preAuth = false where it hooks on 401
+    prepareRequest(options) {
+        options.headers['Authorization'] = 'Bearer ' + this.token;
+        options.headers['X-TFS-FedAuthRedirect'] = 'Suppress';
+    }
+    // This handler cannot handle 401
+    canHandleAuthentication(res) {
+        return false;
+    }
+    handleAuthentication(httpClient, protocol, options, objs, finalCallback) {
+    }
+}
+exports.BearerCredentialHandler = BearerCredentialHandler;

package/Providers/typed-rest-client/handlers/ntlm.d.ts

@@ -1,13 +1,13 @@
-import ifm = require('../Interfaces');
-export declare class NtlmCredentialHandler implements ifm.IRequestHandler {
-    username: string;
-    password: string;
-    workstation: string;
-    domain: string;
-    constructor(username: string, password: string, domain?: string, workstation?: string);
-    prepareRequest(options: any): void;
-    canHandleAuthentication(res: ifm.IHttpResponse): boolean;
-    handleAuthentication(httpClient: any, protocol: any, options: any, objs: any, finalCallback: any): void;
-    private sendType1Message;
-    private sendType3Message;
-}
+import ifm = require('../Interfaces');
+export declare class NtlmCredentialHandler implements ifm.IRequestHandler {
+    username: string;
+    password: string;
+    workstation: string;
+    domain: string;
+    constructor(username: string, password: string, domain?: string, workstation?: string);
+    prepareRequest(options: any): void;
+    canHandleAuthentication(res: ifm.IHttpResponse): boolean;
+    handleAuthentication(httpClient: any, protocol: any, options: any, objs: any, finalCallback: any): void;
+    private sendType1Message(httpClient, protocol, options, objs, keepaliveAgent, callback);
+    private sendType3Message(httpClient, protocol, options, objs, keepaliveAgent, res, callback);
+}

package/Providers/typed-rest-client/handlers/ntlm.js

@@ -1,96 +1,115 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.NtlmCredentialHandler = void 0;
-const http = require("http");
-const https = require("https");
-var _ = require("underscore");
-var ntlm = require("../opensource/node-http-ntlm/ntlm");
-class NtlmCredentialHandler {
-    constructor(username, password, domain, workstation) {
-        this.username = username;
-        this.password = password;
-        if (domain !== undefined) {
-            this.domain = domain;
-        }
-        if (workstation !== undefined) {
-            this.workstation = workstation;
-        }
-    }
-    prepareRequest(options) {
-        if (options.agent) {
-            delete options.agent;
-        }
-    }
-    canHandleAuthentication(res) {
-        if (res && res.statusCode === 401) {
-            var wwwAuthenticate = res.headers['www-authenticate'];
-            if (wwwAuthenticate !== undefined) {
-                var mechanisms = wwwAuthenticate.split(', ');
-                var idx = mechanisms.indexOf("NTLM");
-                if (idx >= 0) {
-                    if (mechanisms[idx].length == 4) {
-                        return true;
-                    }
-                }
-            }
-        }
-        return false;
-    }
-    handleAuthentication(httpClient, protocol, options, objs, finalCallback) {
-        var ntlmOptions = _.extend(options, {
-            username: this.username,
-            password: this.password,
-            domain: this.domain || '',
-            workstation: this.workstation || ''
-        });
-        var keepaliveAgent;
-        if (httpClient.isSsl === true) {
-            keepaliveAgent = new https.Agent({});
-        }
-        else {
-            keepaliveAgent = new http.Agent({ keepAlive: true });
-        }
-        let self = this;
-        this.sendType1Message(httpClient, protocol, ntlmOptions, objs, keepaliveAgent, function (err, res) {
-            if (err) {
-                return finalCallback(err, null, null);
-            }
-            setImmediate(function () {
-                self.sendType3Message(httpClient, protocol, ntlmOptions, objs, keepaliveAgent, res, finalCallback);
-            });
-        });
-    }
-    sendType1Message(httpClient, protocol, options, objs, keepaliveAgent, callback) {
-        var type1msg = ntlm.createType1Message(options);
-        var type1options = {
-            headers: {
-                'Connection': 'keep-alive',
-                'Authorization': type1msg
-            },
-            timeout: options.timeout || 0,
-            agent: keepaliveAgent,
-            allowRedirects: false
-        };
-        type1options = _.extend(type1options, _.omit(options, 'headers'));
-        httpClient.requestInternal(protocol, type1options, objs, callback);
-    }
-    sendType3Message(httpClient, protocol, options, objs, keepaliveAgent, res, callback) {
-        if (!res.headers['www-authenticate']) {
-            return callback(new Error('www-authenticate not found on response of second request'));
-        }
-        var type2msg = ntlm.parseType2Message(res.headers['www-authenticate']);
-        var type3msg = ntlm.createType3Message(type2msg, options);
-        var type3options = {
-            headers: {
-                'Authorization': type3msg
-            },
-            allowRedirects: false,
-            agent: keepaliveAgent
-        };
-        type3options.headers = _.extend(type3options.headers, options.headers);
-        type3options = _.extend(type3options, _.omit(options, 'headers'));
-        httpClient.requestInternal(protocol, type3options, objs, callback);
-    }
-}
-exports.NtlmCredentialHandler = NtlmCredentialHandler;
-//# sourceMappingURL=ntlm.js.map
+"use strict";
+// Copyright (c) Microsoft. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information.
+Object.defineProperty(exports, "__esModule", { value: true });
+const http = require("http");
+const https = require("https");
+var _ = require("underscore");
+var ntlm = require("../opensource/node-http-ntlm/ntlm");
+class NtlmCredentialHandler {
+    constructor(username, password, domain, workstation) {
+        this.username = username;
+        this.password = password;
+        if (domain !== undefined) {
+            this.domain = domain;
+        }
+        if (workstation !== undefined) {
+            this.workstation = workstation;
+        }
+    }
+    prepareRequest(options) {
+        // No headers or options need to be set.  We keep the credentials on the handler itself.
+        // If a (proxy) agent is set, remove it as we don't support proxy for NTLM at this time
+        if (options.agent) {
+            delete options.agent;
+        }
+    }
+    canHandleAuthentication(res) {
+        if (res && res.statusCode === 401) {
+            // Ensure that we're talking NTLM here
+            // Once we have the www-authenticate header, split it so we can ensure we can talk NTLM
+            var wwwAuthenticate = res.headers['www-authenticate'];
+            if (wwwAuthenticate !== undefined) {
+                var mechanisms = wwwAuthenticate.split(', ');
+                var idx = mechanisms.indexOf("NTLM");
+                if (idx >= 0) {
+                    // Check specifically for 'NTLM' since www-authenticate header can also contain
+                    // the Authorization value to use in the form of 'NTLM TlRMTVNT....AAAADw=='
+                    if (mechanisms[idx].length == 4) {
+                        return true;
+                    }
+                }
+            }
+        }
+        return false;
+    }
+    // The following method is an adaptation of code found at https://github.com/SamDecrock/node-http-ntlm/blob/master/httpntlm.js
+    handleAuthentication(httpClient, protocol, options, objs, finalCallback) {
+        // Set up the headers for NTLM authentication
+        var ntlmOptions = _.extend(options, {
+            username: this.username,
+            password: this.password,
+            domain: this.domain || '',
+            workstation: this.workstation || ''
+        });
+        var keepaliveAgent;
+        if (httpClient.isSsl === true) {
+            keepaliveAgent = new https.Agent({});
+        }
+        else {
+            keepaliveAgent = new http.Agent({ keepAlive: true });
+        }
+        let self = this;
+        // The following pattern of sending the type1 message following immediately (in a setImmediate) is
+        // critical for the NTLM exchange to happen.  If we removed setImmediate (or call in a different manner)
+        // the NTLM exchange will always fail with a 401.
+        this.sendType1Message(httpClient, protocol, ntlmOptions, objs, keepaliveAgent, function (err, res) {
+            if (err) {
+                return finalCallback(err, null, null);
+            }
+            setImmediate(function () {
+                self.sendType3Message(httpClient, protocol, ntlmOptions, objs, keepaliveAgent, res, finalCallback);
+            });
+        });
+    }
+    // The following method is an adaptation of code found at https://github.com/SamDecrock/node-http-ntlm/blob/master/httpntlm.js
+    sendType1Message(httpClient, protocol, options, objs, keepaliveAgent, callback) {
+        var type1msg = ntlm.createType1Message(options);
+        var type1options = {
+            headers: {
+                'Connection': 'keep-alive',
+                'Authorization': type1msg
+            },
+            timeout: options.timeout || 0,
+            agent: keepaliveAgent,
+            // don't redirect because http could change to https which means we need to change the keepaliveAgent
+            allowRedirects: false
+        };
+        type1options = _.extend(type1options, _.omit(options, 'headers'));
+        httpClient.requestInternal(protocol, type1options, objs, callback);
+    }
+    // The following method is an adaptation of code found at https://github.com/SamDecrock/node-http-ntlm/blob/master/httpntlm.js
+    sendType3Message(httpClient, protocol, options, objs, keepaliveAgent, res, callback) {
+        if (!res.headers['www-authenticate']) {
+            return callback(new Error('www-authenticate not found on response of second request'));
+        }
+        // parse type2 message from server:
+        var type2msg = ntlm.parseType2Message(res.headers['www-authenticate']);
+        // create type3 message:
+        var type3msg = ntlm.createType3Message(type2msg, options);
+        // build type3 request:
+        var type3options = {
+            headers: {
+                'Authorization': type3msg
+            },
+            allowRedirects: false,
+            agent: keepaliveAgent
+        };
+        // pass along other options:
+        type3options.headers = _.extend(type3options.headers, options.headers);
+        type3options = _.extend(type3options, _.omit(options, 'headers'));
+        // send type3 message to server:
+        httpClient.requestInternal(protocol, type3options, objs, callback);
+    }
+}
+exports.NtlmCredentialHandler = NtlmCredentialHandler;

package/Providers/typed-rest-client/handlers/personalaccesstoken.d.ts

@@ -1,8 +1,8 @@
-import ifm = require('../Interfaces');
-export declare class PersonalAccessTokenCredentialHandler implements ifm.IRequestHandler {
-    token: string;
-    constructor(token: string);
-    prepareRequest(options: any): void;
-    canHandleAuthentication(res: ifm.IHttpResponse): boolean;
-    handleAuthentication(httpClient: any, protocol: any, options: any, objs: any, finalCallback: any): void;
-}
+import ifm = require('../Interfaces');
+export declare class PersonalAccessTokenCredentialHandler implements ifm.IRequestHandler {
+    token: string;
+    constructor(token: string);
+    prepareRequest(options: any): void;
+    canHandleAuthentication(res: ifm.IHttpResponse): boolean;
+    handleAuthentication(httpClient: any, protocol: any, options: any, objs: any, finalCallback: any): void;
+}

package/Providers/typed-rest-client/handlers/personalaccesstoken.js

@@ -1,19 +1,22 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.PersonalAccessTokenCredentialHandler = void 0;
-class PersonalAccessTokenCredentialHandler {
-    constructor(token) {
-        this.token = token;
-    }
-    prepareRequest(options) {
-        options.headers['Authorization'] = 'Basic ' + new Buffer('PAT:' + this.token).toString('base64');
-        options.headers['X-TFS-FedAuthRedirect'] = 'Suppress';
-    }
-    canHandleAuthentication(res) {
-        return false;
-    }
-    handleAuthentication(httpClient, protocol, options, objs, finalCallback) {
-    }
-}
-exports.PersonalAccessTokenCredentialHandler = PersonalAccessTokenCredentialHandler;
-//# sourceMappingURL=personalaccesstoken.js.map
+"use strict";
+// Copyright (c) Microsoft. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information.
+Object.defineProperty(exports, "__esModule", { value: true });
+class PersonalAccessTokenCredentialHandler {
+    constructor(token) {
+        this.token = token;
+    }
+    // currently implements pre-authorization
+    // TODO: support preAuth = false where it hooks on 401
+    prepareRequest(options) {
+        options.headers['Authorization'] = 'Basic ' + new Buffer('PAT:' + this.token).toString('base64');
+        options.headers['X-TFS-FedAuthRedirect'] = 'Suppress';
+    }
+    // This handler cannot handle 401
+    canHandleAuthentication(res) {
+        return false;
+    }
+    handleAuthentication(httpClient, protocol, options, objs, finalCallback) {
+    }
+}
+exports.PersonalAccessTokenCredentialHandler = PersonalAccessTokenCredentialHandler;

package/Providers/typed-rest-client/opensource/node-http-ntlm/readme.txt

@@ -0,0 +1,6 @@
+// This software (ntlm.js) was copied from a file of the same name at https://github.com/SamDecrock/node-http-ntlm/blob/master/ntlm.js.
+//
+// As of this writing, it is a part of the node-http-ntlm module produced by SamDecrock.
+//
+// It is used as a part of the NTLM support provided by the vso-node-api library.
+//

package/Providers/webClient.d.ts

@@ -1,8 +1,8 @@
-import * as httpm from './typed-rest-client/HttpClient';
-export declare class WebClient {
-    private httpc;
-    constructor(handlers: any, options: any);
-    get(requestUrl: string, additionalHeaders?: any): Promise<httpm.HttpClientResponse>;
-    dispose(): void;
-    processResponse(res: httpm.HttpClientResponse): Promise<void>;
-}
+import * as httpm from './typed-rest-client/HttpClient';
+export declare class WebClient {
+    private httpc;
+    constructor(handlers: any, options: any);
+    get(requestUrl: string, additionalHeaders?: any): Promise<httpm.HttpClientResponse>;
+    dispose(): void;
+    processResponse(res: httpm.HttpClientResponse): Promise<void>;
+}

package/Providers/webClient.js

@@ -1,60 +1,60 @@
-"use strict";
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.WebClient = void 0;
-const httpm = require("./typed-rest-client/HttpClient");
-var tl = require('azure-pipelines-task-lib/task');
-var packagejson = require('../package.json');
-class WebClient {
-    constructor(handlers, options) {
-        this.httpc = new httpm.HttpClient('artifact-engine ' + packagejson.version, handlers, options);
-    }
-    get(requestUrl, additionalHeaders) {
-        var promise = new Promise((resolve, reject) => {
-            this.httpc.get(requestUrl, additionalHeaders).then((res) => {
-                this.processResponse(res).then(() => {
-                    resolve(res);
-                }, (err) => {
-                    reject(err);
-                });
-            }, (err) => {
-                reject(err);
-            });
-        });
-        return promise;
-    }
-    dispose() {
-        this.httpc.dispose();
-    }
-    processResponse(res) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const statusCode = res.message.statusCode;
-            let err;
-            if (statusCode > 299) {
-                let obj;
-                var msg = tl.loc("FailedRequest", statusCode);
-                err = new Error(msg);
-                err['statusCode'] = statusCode;
-                try {
-                    let result = yield res.readBody();
-                    err['result'] = result;
-                }
-                catch (error) {
-                }
-            }
-            if (!!err) {
-                throw err;
-            }
-        });
-    }
-}
-exports.WebClient = WebClient;
-//# sourceMappingURL=webClient.js.map
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : new P(function (resolve) { resolve(result.value); }).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+// restrict usage of typed-rest-client to this file
+const httpm = require("./typed-rest-client/HttpClient");
+var tl = require('azure-pipelines-task-lib/task');
+var packagejson = require('../package.json');
+class WebClient {
+    constructor(handlers, options) {
+        this.httpc = new httpm.HttpClient('artifact-engine ' + packagejson.version, handlers, options);
+    }
+    get(requestUrl, additionalHeaders) {
+        var promise = new Promise((resolve, reject) => {
+            this.httpc.get(requestUrl, additionalHeaders).then((res) => {
+                this.processResponse(res).then(() => {
+                    resolve(res);
+                }, (err) => {
+                    reject(err);
+                });
+            }, (err) => {
+                reject(err);
+            });
+        });
+        return promise;
+    }
+    dispose() {
+        this.httpc.dispose();
+    }
+    processResponse(res) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const statusCode = res.message.statusCode;
+            let err;
+            if (statusCode > 299) {
+                let obj;
+                var msg = tl.loc("FailedRequest", statusCode);
+                err = new Error(msg);
+                err['statusCode'] = statusCode;
+                // get the result from the body
+                try {
+                    let result = yield res.readBody();
+                    err['result'] = result;
+                }
+                catch (error) {
+                    // Invalid contents;  leaving result obj null
+                }
+            }
+            if (!!err) {
+                throw err;
+            }
+        });
+    }
+}
+exports.WebClient = WebClient;

package/Providers/webClientFactory.d.ts

@@ -1,5 +1,5 @@
-export declare class WebClientFactory {
-    static getClient(handlers: any[], options: any): any;
-    private static initializeProxy;
-    private static _readTaskLibSecrets;
-}
+export declare class WebClientFactory {
+    static getClient(handlers: any[], options: any): any;
+    private static initializeProxy(options);
+    private static _readTaskLibSecrets(lookupKey);
+}