askui 0.4.0 → 0.6.0

package/dist/cjs/execution/dsl.js

@@ -799,6 +799,120 @@ class FluentFilters extends FluentBase {
 exports.FluentFilters = FluentFilters;
 // Relations
 class FluentFiltersOrRelations extends FluentFilters {
+    /**
+     * Logic or operator
+     *
+     * **Examples:**
+     * ```text
+     * scene 1
+     * --------------  ---------------
+     * |  button    |  |  icon       |
+     * --------------  ---------------
+     *
+     * scene 2
+     * --------------  ---------------
+     * |  button    |  |  text       |
+     * --------------  ---------------
+     *
+     * ```
+     * In case, that your reference element can have multiple values, in the following example, the element right of the button can be either icon or text.
+     * You can use **the `or()` relation**, so your teststep is valid for both scenes
+     * ```typescript
+     * const button = await aui.get().button().rightOf().icon().or().text().exec();
+     * console.log(button);
+     * ```
+     * Returns the same button for both cases
+     * ```text
+     *  console output: [
+     *   DetectedElement {
+     *      name: 'BUTTON',
+     *      text: 'button',
+     *      colors: [ 'red', 'black', 'red' ],
+     *      bndbox: BoundingBox {
+     *         xmin: 900,
+     *         ymin: 910,
+     *         xmax: 920,
+     *         ymax: 930
+     *      }
+     *   }
+     *  ]
+     * ```
+     *
+     * @return {FluentFilters}
+     */
+    or() {
+        this._textStr = 'or';
+        return new FluentFilters(this);
+    }
+    /**
+     * Logic and operator
+     *
+     * **Examples:**
+     * ```text
+     * example scene:
+     *  --------------------------   --------------------------
+     *  |  icon user colored black | |  icon  user colored red |
+     *  --------------------------   --------------------------
+     * ```
+     * ```typescript
+     * const icons = await aui.get().icon().withText('user').exec();
+     * console.log(icons);
+     * ```
+     * Using only the filter withText, the get command will return both icons because they share the same text
+     * ```text
+     * console output: [
+     *   DetectedElement {
+     *      name: 'ICON',
+     *      text: 'user',
+     *      colors: [ 'black', 'black', 'black' ],
+     *      bndbox: BoundingBox {
+     *         xmin: 1000,
+     *         ymin: 1010,
+     *         xmax: 1020,
+     *         ymax: 1030
+     *      }
+     *   },
+     *   DetectedElement {
+     *      name: 'ICON',
+     *      text: 'user',
+     *      colors: [ 'red', 'red', 'red' ],
+     *      bndbox: BoundingBox {
+     *         xmin: 900,
+     *         ymin: 910,
+     *         xmax: 920,
+     *         ymax: 930
+     *      }
+     *   }
+     *  ]
+     * ```
+     * You can combine filters with **the `and()` relation** and specify exactly which icon you want
+     * ```typescript
+     * const icons = await aui.get().icon().withText('user').and().colored('red').exec()
+     * console.log(icons)
+     * ```
+     * The get command returns only the red icon although both icons have the same text
+     * ```text
+     *  console output: [
+     *   DetectedElement {
+     *      name: 'ICON',
+     *      text: 'user',
+     *      colors: [ 'red', 'red', 'red' ],
+     *      bndbox: BoundingBox {
+     *         xmin: 900,
+     *         ymin: 910,
+     *         xmax: 920,
+     *         ymax: 930
+     *      }
+     *   }
+     *  ]
+     * ```
+     *
+     * @return {FluentFilters}
+     */
+    and() {
+        this._textStr = 'and';
+        return new FluentFilters(this);
+    }
     /**
      * Filters for an element inside another element.
      *
@@ -1711,6 +1825,120 @@ class FluentFiltersCondition extends FluentBase {
 exports.FluentFiltersCondition = FluentFiltersCondition;
 // Relations
 class FluentFiltersOrRelationsCondition extends FluentFiltersCondition {
+    /**
+     * Logic or operator
+     *
+     * **Examples:**
+     * ```text
+     * scene 1
+     * --------------  ---------------
+     * |  button    |  |  icon       |
+     * --------------  ---------------
+     *
+     * scene 2
+     * --------------  ---------------
+     * |  button    |  |  text       |
+     * --------------  ---------------
+     *
+     * ```
+     * In case, that your reference element can have multiple values, in the following example, the element right of the button can be either icon or text.
+     * You can use **the `or()` relation**, so your teststep is valid for both scenes
+     * ```typescript
+     * const button = await aui.get().button().rightOf().icon().or().text().exec();
+     * console.log(button);
+     * ```
+     * Returns the same button for both cases
+     * ```text
+     *  console output: [
+     *   DetectedElement {
+     *      name: 'BUTTON',
+     *      text: 'button',
+     *      colors: [ 'red', 'black', 'red' ],
+     *      bndbox: BoundingBox {
+     *         xmin: 900,
+     *         ymin: 910,
+     *         xmax: 920,
+     *         ymax: 930
+     *      }
+     *   }
+     *  ]
+     * ```
+     *
+     * @return {FluentFiltersCondition}
+     */
+    or() {
+        this._textStr = 'or';
+        return new FluentFiltersCondition(this);
+    }
+    /**
+     * Logic and operator
+     *
+     * **Examples:**
+     * ```text
+     * example scene:
+     *  --------------------------   --------------------------
+     *  |  icon user colored black | |  icon  user colored red |
+     *  --------------------------   --------------------------
+     * ```
+     * ```typescript
+     * const icons = await aui.get().icon().withText('user').exec();
+     * console.log(icons);
+     * ```
+     * Using only the filter withText, the get command will return both icons because they share the same text
+     * ```text
+     * console output: [
+     *   DetectedElement {
+     *      name: 'ICON',
+     *      text: 'user',
+     *      colors: [ 'black', 'black', 'black' ],
+     *      bndbox: BoundingBox {
+     *         xmin: 1000,
+     *         ymin: 1010,
+     *         xmax: 1020,
+     *         ymax: 1030
+     *      }
+     *   },
+     *   DetectedElement {
+     *      name: 'ICON',
+     *      text: 'user',
+     *      colors: [ 'red', 'red', 'red' ],
+     *      bndbox: BoundingBox {
+     *         xmin: 900,
+     *         ymin: 910,
+     *         xmax: 920,
+     *         ymax: 930
+     *      }
+     *   }
+     *  ]
+     * ```
+     * You can combine filters with **the `and()` relation** and specify exactly which icon you want
+     * ```typescript
+     * const icons = await aui.get().icon().withText('user').and().colored('red').exec()
+     * console.log(icons)
+     * ```
+     * The get command returns only the red icon although both icons have the same text
+     * ```text
+     *  console output: [
+     *   DetectedElement {
+     *      name: 'ICON',
+     *      text: 'user',
+     *      colors: [ 'red', 'red', 'red' ],
+     *      bndbox: BoundingBox {
+     *         xmin: 900,
+     *         ymin: 910,
+     *         xmax: 920,
+     *         ymax: 930
+     *      }
+     *   }
+     *  ]
+     * ```
+     *
+     * @return {FluentFiltersCondition}
+     */
+    and() {
+        this._textStr = 'and';
+        return new FluentFiltersCondition(this);
+    }
     /**
      * Filters for an element inside another element.
      *
@@ -2933,6 +3161,120 @@ class FluentFiltersGetter extends FluentBase {
 exports.FluentFiltersGetter = FluentFiltersGetter;
 // Relations
 class FluentFiltersOrRelationsGetter extends FluentFiltersGetter {
+    /**
+     * Logic or operator
+     *
+     * **Examples:**
+     * ```text
+     * scene 1
+     * --------------  ---------------
+     * |  button    |  |  icon       |
+     * --------------  ---------------
+     *
+     * scene 2
+     * --------------  ---------------
+     * |  button    |  |  text       |
+     * --------------  ---------------
+     *
+     * ```
+     * In case, that your reference element can have multiple values, in the following example, the element right of the button can be either icon or text.
+     * You can use **the `or()` relation**, so your teststep is valid for both scenes
+     * ```typescript
+     * const button = await aui.get().button().rightOf().icon().or().text().exec();
+     * console.log(button);
+     * ```
+     * Returns the same button for both cases
+     * ```text
+     *  console output: [
+     *   DetectedElement {
+     *      name: 'BUTTON',
+     *      text: 'button',
+     *      colors: [ 'red', 'black', 'red' ],
+     *      bndbox: BoundingBox {
+     *         xmin: 900,
+     *         ymin: 910,
+     *         xmax: 920,
+     *         ymax: 930
+     *      }
+     *   }
+     *  ]
+     * ```
+     *
+     * @return {FluentFiltersGetter}
+     */
+    or() {
+        this._textStr = 'or';
+        return new FluentFiltersGetter(this);
+    }
+    /**
+     * Logic and operator
+     *
+     * **Examples:**
+     * ```text
+     * example scene:
+     *  --------------------------   --------------------------
+     *  |  icon user colored black | |  icon  user colored red |
+     *  --------------------------   --------------------------
+     * ```
+     * ```typescript
+     * const icons = await aui.get().icon().withText('user').exec();
+     * console.log(icons);
+     * ```
+     * Using only the filter withText, the get command will return both icons because they share the same text
+     * ```text
+     * console output: [
+     *   DetectedElement {
+     *      name: 'ICON',
+     *      text: 'user',
+     *      colors: [ 'black', 'black', 'black' ],
+     *      bndbox: BoundingBox {
+     *         xmin: 1000,
+     *         ymin: 1010,
+     *         xmax: 1020,
+     *         ymax: 1030
+     *      }
+     *   },
+     *   DetectedElement {
+     *      name: 'ICON',
+     *      text: 'user',
+     *      colors: [ 'red', 'red', 'red' ],
+     *      bndbox: BoundingBox {
+     *         xmin: 900,
+     *         ymin: 910,
+     *         xmax: 920,
+     *         ymax: 930
+     *      }
+     *   }
+     *  ]
+     * ```
+     * You can combine filters with **the `and()` relation** and specify exactly which icon you want
+     * ```typescript
+     * const icons = await aui.get().icon().withText('user').and().colored('red').exec()
+     * console.log(icons)
+     * ```
+     * The get command returns only the red icon although both icons have the same text
+     * ```text
+     *  console output: [
+     *   DetectedElement {
+     *      name: 'ICON',
+     *      text: 'user',
+     *      colors: [ 'red', 'red', 'red' ],
+     *      bndbox: BoundingBox {
+     *         xmin: 900,
+     *         ymin: 910,
+     *         xmax: 920,
+     *         ymax: 930
+     *      }
+     *   }
+     *  ]
+     * ```
+     *
+     * @return {FluentFiltersGetter}
+     */
+    and() {
+        this._textStr = 'and';
+        return new FluentFiltersGetter(this);
+    }
     /**
      * Filters for an element inside another element.
      *
@@ -3114,7 +3456,32 @@ exports.FluentFiltersOrRelationsGetter = FluentFiltersOrRelationsGetter;
 // Commands
 class Getter extends FluentCommand {
     /**
-     * Returns the filtered element
+     * Returns an array with all filtered elements.
+     * A detected element has the following properties:
+     * - `name` of the element
+     * - `text` content of element
+     * - `colors` of element
+     * - `bndbox`: location of element described with coordinates of a bounding box
+     * **Examples:**
+     * ```typescript
+     * const text = await aui.get().text().withText('Sign').exec();
+     * console.log(text);
+     * ```
+     * ```text
+     *  console output: [
+     *   DetectedElement {
+     *      name: 'TEXT',
+     *      text: 'Sign In',
+     *      colors: [ 'black', 'gray', 'gray' ],
+     *      bndbox: BoundingBox {
+     *         xmin: 1128.2720982142857,
+     *         ymin: 160.21332310267857,
+     *         xmax: 1178.8204241071428,
+     *         ymax: 180.83512834821428
+     *      }
+     *  }
+     *  ]
+     * ```
      *
      * @return {FluentFiltersGetter}
      */
@@ -3123,7 +3490,43 @@ class Getter extends FluentCommand {
         return new FluentFiltersGetter(this);
     }
     /**
-     * Returns all detected elements
+     * Returns an array with all detected elements.
+     * A detected element has the following properties:
+     * - `name` of the element
+     * - `text` content of element
+     * - `colors` of element
+     * - `bndbox`: location of element described with coordinates of a bounding box
+     * **Examples:**
+     * ```typescript
+     * const detectedElements = await aui.getAll().exec();
+     * console.log(detectedElements);
+     * ```
+     * ```text
+     *  console output: [
+     *   DetectedElement {
+     *      name: 'TEXT',
+     *      text: 'Sign In',
+     *      colors: [ 'black', 'gray', 'gray' ],
+     *      bndbox: BoundingBox {
+     *         xmin: 1128.2720982142857,
+     *         ymin: 160.21332310267857,
+     *         xmax: 1178.8204241071428,
+     *         ymax: 180.83512834821428
+     *      },
+     *   DetectedElement {
+     *      name: 'ICON',
+     *      text: 'search',
+     *      colors: [ 'black', 'red', 'gray' ],
+     *      bndbox: BoundingBox {
+     *         xmin: 250.8204241071428,
+     *         ymin: 300.21332310267857,
+     *         xmax: 450.6304241071428,
+     *         ymax: 950.47812834821428
+     *      },
+     *      ... 381 more items
+     *  }
+     *  ]
+     * ```
      *
      * @return {ExecGetter}
      */

package/dist/cjs/execution/inference-client.d.ts

@@ -6,10 +6,11 @@ import { DetectedElement } from '../core/model/annotation-result/detected-elemen
 export declare class InferenceClient {
     baseUrl: string;
     httpClient: HttpClientGot;
+    resize?: number | undefined;
     readonly workspaceId?: string | undefined;
     apiVersion: string;
     url: string;
-    constructor(baseUrl: string, httpClient: HttpClientGot, workspaceId?: string | undefined, apiVersion?: string);
+    constructor(baseUrl: string, httpClient: HttpClientGot, resize?: number | undefined, workspaceId?: string | undefined, apiVersion?: string);
     isImageRequired(instruction: string): Promise<boolean>;
     private resizeIfNeeded;
     inference(customElements?: CustomElement[], image?: string, instruction?: string): Promise<ControlCommand | Annotation>;

package/dist/cjs/execution/inference-client.js

@@ -18,14 +18,20 @@ const ui_control_commands_1 = require("../core/ui-control-commands");
 const annotation_1 = require("../core/annotation/annotation");
 const transformations_1 = require("../utils/transformations");
 const inference_response_error_1 = require("./inference-response-error");
+const config_error_1 = require("./config-error");
 class InferenceClient {
-    constructor(baseUrl, httpClient, workspaceId, apiVersion = 'v3') {
+    constructor(baseUrl, httpClient, resize, workspaceId, apiVersion = 'v3') {
         this.baseUrl = baseUrl;
         this.httpClient = httpClient;
+        this.resize = resize;
         this.workspaceId = workspaceId;
         this.apiVersion = apiVersion;
         const versionedBaseUrl = (0, url_join_1.default)(this.baseUrl, 'api', this.apiVersion);
         this.url = workspaceId ? (0, url_join_1.default)(versionedBaseUrl, 'workspaces', workspaceId) : versionedBaseUrl;
+        if (this.resize !== undefined && this.resize <= 0) {
+            throw new config_error_1.ConfigurationError(`Resize must be a positive number. The current resize value "${this.resize}" is not valid.`);
+        }
+        this.resize = this.resize ? Math.ceil(this.resize) : this.resize;
     }
     isImageRequired(instruction) {
         return __awaiter(this, void 0, void 0, function* () {
@@ -40,10 +46,10 @@ class InferenceClient {
     // eslint-disable-next-line class-methods-use-this
     resizeIfNeeded(customElements, image) {
         return __awaiter(this, void 0, void 0, function* () {
-            if (!(image) || customElements.length > 0) {
+            if (!(image) || customElements.length > 0 || this.resize === undefined) {
                 return { base64Image: image, resizeRatio: 1 };
             }
-            return (0, transformations_1.resizeBase64ImageWithSameRatio)(image);
+            return (0, transformations_1.resizeBase64ImageWithSameRatio)(image, this.resize);
         });
     }
     inference(customElements = [], image, instruction) {

package/dist/cjs/execution/ui-control-client.js

@@ -23,6 +23,7 @@ const annotation_level_1 = require("./annotation-level");
 const ui_control_client_error_1 = require("./ui-control-client-error");
 const read_environment_credentials_1 = require("./read-environment-credentials");
 const analytics_1 = require("../utils/analytics");
+const proxy_builder_1 = require("../utils/proxy/proxy-builder");
 const getClientArgsWithDefaults = (clientArgs = {}) => (Object.assign({ uiControllerUrl: 'http://127.0.0.1:6769', inferenceServerUrl: 'https://inference.askui.com', annotationLevel: annotation_level_1.AnnotationLevel.DISABLED }, clientArgs));
 class UiControlClient extends dsl_1.ApiCommands {
     constructor(httpClient, clientArgs, workspaceId) {
@@ -39,7 +40,8 @@ class UiControlClient extends dsl_1.ApiCommands {
             const analyticsCookies = yield analytics.getAnalyticsCookies();
             const cas = getClientArgsWithDefaults(clientArgs);
             const credentialArgs = cas.credentials || (0, read_environment_credentials_1.envCredentials)();
-            const httpClient = new http_client_got_1.HttpClientGot(credentialArgs === null || credentialArgs === void 0 ? void 0 : credentialArgs.token, analyticsHeaders, analyticsCookies);
+            const proxyAgentArgs = cas.proxyAgents || (yield (0, proxy_builder_1.buildProxyAgentArgsFromEnvironment)());
+            const httpClient = new http_client_got_1.HttpClientGot(credentialArgs === null || credentialArgs === void 0 ? void 0 : credentialArgs.token, analyticsHeaders, analyticsCookies, proxyAgentArgs);
             return new UiControlClient(httpClient, cas, credentialArgs === null || credentialArgs === void 0 ? void 0 : credentialArgs.workspaceId);
         });
     }
@@ -50,7 +52,7 @@ class UiControlClient extends dsl_1.ApiCommands {
         return this._uiControllerClient;
     }
     get inferenceClient() {
-        return new inference_client_1.InferenceClient(this.clientArgs.inferenceServerUrl, this.httpClient, this.workspaceId);
+        return new inference_client_1.InferenceClient(this.clientArgs.inferenceServerUrl, this.httpClient, this.clientArgs.resize, this.workspaceId);
     }
     get executionRuntime() {
         return new execution_runtime_1.ExecutionRuntime(this.uiControllerClient, this.inferenceClient);

package/dist/cjs/execution/ui-controller-client-interface.d.ts

@@ -1,10 +1,19 @@
 import { AnnotationLevel } from './annotation-level';
 import { CredentialArgs } from './credentials-args';
+import { ProxyAgentArgs } from '../shared/proxy-agent-args';
 /**
  * Configuration options for the askui UI Control Client
  *
  * @param {string} uiControllerUrl - Default: http://127.0.0.1:6769
  * The adress of the askui UI Controller server.
+ * @param {(number | undefined)} resize - Default: undefined
+ * The resizing will be skipped if it's undefined.
+ * The side length of the target image to resize to in px.
+ * Your screenshot image will be resized with the original aspect ratio,
+ *  and the lengths image side will be equal to this number.
+ * This can be used to reduce the inference time by reducing
+ *  the request size in case of a bad internet connection.
+ * But it can cause a decrease in the prediction quality.
  * @param {string} inferenceClientUrl - Default: https://inference.askui.com`
  * Address of the askui Inference server.
  * @param {AnnotationLevel} annotationLevel - Default: AnnotationLevel.DISABLED
@@ -13,12 +22,16 @@ import { CredentialArgs } from './credentials-args';
  * You have three options: `DISABLED`, `ON_FAILURE`, `ALL`.
  * @param {CredentialArgs} credentials - We need to provide credentials for
  * the authentication of the askui Inference Server.
+ * You have three options: `DISABLED`, `ON_FAILURE`, `ALL`.
+ * @param {ProxyAgentArgs} proxyAgents - To configure the proxy agents for http(s) requests.
  */
 export interface ClientArgs {
     readonly uiControllerUrl?: string;
     readonly inferenceServerUrl?: string;
     readonly annotationLevel?: AnnotationLevel;
     readonly credentials?: CredentialArgs;
+    readonly proxyAgents?: ProxyAgentArgs;
+    readonly resize?: number;
 }
 export interface ClientArgsWithDefaults extends ClientArgs {
     readonly uiControllerUrl: string;

package/dist/cjs/lib/copy-example-project.js

@@ -1,4 +1,13 @@
 "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());
+    });
+};
 var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
@@ -8,14 +17,36 @@ const commander_1 = require("commander");
 const path_1 = __importDefault(require("path"));
 const fs_extra_1 = __importDefault(require("fs-extra"));
 const path_2 = require("../utils/path");
+const logger_1 = require("./logger");
 const createProgram = () => {
     const program = new commander_1.Command('askui');
     program.usage('<command> [options]');
     return program;
 };
-function copyExampleProject() {
-    const exampleProjectPath = path_1.default.join('example_projects_templates', 'typescript_jest');
-    fs_extra_1.default.copySync(path_1.default.join((0, path_2.getPathToNodeModulesRoot)(), exampleProjectPath), '.');
+function replaceStringInFile(filePath, replace, replacement) {
+    return __awaiter(this, void 0, void 0, function* () {
+        try {
+            const data = yield fs_extra_1.default.readFile(filePath, 'utf8');
+            const result = data.replace(replace, replacement);
+            yield fs_extra_1.default.writeFile(filePath, result, 'utf8');
+        }
+        catch (error) {
+            logger_1.logger.error(`Could not replace '${replace}' with '${replacement}' in file '${path_1.default}'`);
+            logger_1.logger.error(error.message);
+        }
+    });
+}
+function copyExampleProject(options) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const exampleProjectPath = path_1.default.join('example_projects_templates', 'typescript_jest');
+        fs_extra_1.default.copySync(path_1.default.join((0, path_2.getPathToNodeModulesRoot)(), exampleProjectPath), '.');
+        if (options['workspaceId']) {
+            yield replaceStringInFile('./test/helper/jest.setup.ts', '<your workspace id>', options['workspaceId']);
+        }
+        if (options['accessToken']) {
+            yield replaceStringInFile('./test/helper/jest.setup.ts', '<your access token>', options['accessToken']);
+        }
+    });
 }
 function init(argv) {
     const args = argv || process.argv;
@@ -23,7 +54,12 @@ function init(argv) {
     program
         .command('init')
         .description('creates a typescript example project')
-        .action(() => { copyExampleProject(); });
+        .option('-w, --workspace-id <value>', 'a workspace id')
+        .option('-a, --access-token <value>', 'an access token for the workspace with the id')
+        .usage('[-w workspace_id] [-a access_token]')
+        .action((opts) => __awaiter(this, void 0, void 0, function* () {
+        yield copyExampleProject(opts);
+    }));
     return program.parse(args);
 }
 exports.init = init;

package/dist/cjs/lib/download-binaries.d.ts

@@ -1,3 +1,6 @@
+/// <reference types="node" />
+import http from 'http';
+import https from 'https';
 declare enum SupportedPlatform {
     LINUX = "linux",
     DARWIN = "darwin",
@@ -5,5 +8,8 @@ declare enum SupportedPlatform {
 }
 export declare function platform(): SupportedPlatform;
 export declare function getBinaryPath(version: string): string;
-export declare function downloadServerBinaries(binaryVersion: string): Promise<void>;
+export declare function downloadServerBinaries(binaryVersion: string, proxyAgent?: {
+    http: http.Agent;
+    https: https.Agent;
+}): Promise<void>;
 export {};

package/dist/cjs/lib/download-binaries.js

@@ -44,7 +44,7 @@ function getBinaryDownloadUrl(binaryVersion) {
     const arch = os_1.default.arch();
     return `${baseUrl}/${platform()}/${arch}/${binarySubPathsByPlatform[platform()][1]}`;
 }
-function downloadServerBinaries(binaryVersion) {
+function downloadServerBinaries(binaryVersion, proxyAgent) {
     return new Promise((resolve, reject) => {
         const url = getBinaryDownloadUrl(binaryVersion);
         const binaryOutputPath = getBinaryPath(binaryVersion);
@@ -53,7 +53,7 @@ function downloadServerBinaries(binaryVersion) {
         if (!(fs_1.default.existsSync(binaryFolder))) {
             fs_1.default.mkdirSync(binaryFolder, { recursive: true });
         }
-        const downloadStream = got_1.default.stream(url);
+        const downloadStream = got_1.default.stream(url, proxyAgent ? { agent: proxyAgent } : {});
         const fileWriterStream = fs_1.default.createWriteStream(binaryOutputPath);
         downloadStream.on('error', () => {
             reject();

package/dist/cjs/lib/ui-controller-args.d.ts

@@ -1,3 +1,4 @@
+import { ProxyAgentArgs } from '../shared/proxy-agent-args';
 import { LogLevels } from '../shared/log-levels';
 /**
  * Configuration options for the askui UI Controller
@@ -5,6 +6,7 @@ import { LogLevels } from '../shared/log-levels';
  * @param {number} display - Default: `0`
  * You can choose on which display you want to excecute all tests.
  * 0 is your main monitor.
+ *
  * If you want to use your second monitor you can change
  * the value to `1` (`2` for your third monitor etc.).
  * @param {string} binaryVersion - Default: `'latest'`
@@ -26,6 +28,7 @@ import { LogLevels } from '../shared/log-levels';
  * @param {string} logFilePath - Default: `'<temp-dir>/askui/askui-server.log'`
  * It is possible to specify a path for your log files.
  * Per default we create the askui-server.log file and askui folder in your temp folder.
+ * @param {ProxyAgentArgs} proxyAgents - To configure the proxy agents for our http(s) requests.
  */
 export interface UiControllerArgs {
     readonly display?: number;
@@ -37,6 +40,7 @@ export interface UiControllerArgs {
     readonly overWriteBinary?: boolean;
     readonly logLevel?: LogLevels;
     readonly logFilePath?: string;
+    readonly proxyAgents?: ProxyAgentArgs;
 }
 export interface UiControllerArgsWithDefaults extends UiControllerArgs {
     readonly display: number;