askui 0.1.6 → 0.2.2

package/dist/cjs/execution/ui-control-client.d.ts

@@ -0,0 +1,79 @@
+import { CustomElementJson } from '../core/model/test-case-dto';
+import { Exec, Executable, FluentCommand, FluentFilters } from './dsl';
+import { UiControllerClientConnectionState } from './ui-controller-client-connection-state';
+import { Annotation } from '../core/annotation/annotation';
+import { AnnotationRequest } from '../core/model/annotation-result/annotation-interface';
+import { ClientArgs } from './ui-controller-client-interface';
+export declare class UiControlClient extends FluentCommand {
+    private httpClient;
+    private clientArgs;
+    private _uiControllerClient?;
+    private constructor();
+    static build(clientArgs?: ClientArgs): Promise<UiControlClient>;
+    private get uiControllerClient();
+    private get inferenceClient();
+    private get executionRuntime();
+    private annotateByDefault;
+    connect(): Promise<UiControllerClientConnectionState>;
+    annotate(annotationRequest?: AnnotationRequest): Promise<Annotation>;
+    annotateInteractively(): Promise<void>;
+    exec(instruction: string, customElementJson?: CustomElementJson[]): Promise<void>;
+    private secretText;
+    /**
+     * Types a text inside the filtered element.
+     *
+     * By default, the `text` is included in the logs and sent over to the askui Inference server to
+     * predict in which context the typing has to occur. You can exclude the `text` from the logs
+     * and the request to the askui Inference server setting `options.isSecret` to `true`.
+     * This should not change the quality of the prediction of the askui Inference server. In this
+     * case, `options.secretMask` is included in logs and sent over instead of the `text`.
+     *
+     * @param {string} text - A text to type.
+     * @param {Object} [options]
+     * @param {boolean} [options.isSecret = false] - If set to `true`, `text` is neither included in
+     *   logs of askui nor sent over to askui Inference for prediction.
+     * @param {string} [options.secretMask = '****'] - If `options.isSecret` is set to `true`, this
+     *   is included in logs and sent over to askui Inference for prediction instead of the `text`.
+     *
+     * @return {FluentFilters}
+     */
+    typeIn(text: string, { isSecret, secretMask }?: {
+        isSecret?: boolean | undefined;
+        secretMask?: string | undefined;
+    }): FluentFilters;
+    /**
+     * Types a text at the current position.
+     *
+     * By default, the `text` is included in the logs and sent over to the askui Inference server to
+     * predict in which context the typing has to occur. You can exclude the `text` from the logs
+     * and the request to the askui Inference server setting `options.isSecret` to `true`.
+     * This should not change the quality of the prediction of the askui Inference server. In this
+     * case, `options.secretMask` is included in logs and sent over instead of the `text`.
+     *
+     * @param {string} text - A text to type.
+     * @param {Object} options
+     * @param {boolean} [options.isSecret = false] - If set to `true`, `text` is neither included in
+     *   logs of askui nor sent over to askui Inference for prediction.
+     * @param {string} [options.secretMask = '****'] - If `options.isSecret` is set to `true`, this
+     *   is included in logs and sent over to askui Inference for prediction instead of the `text`.
+     *
+     * @return {Exec}
+     */
+    type(text: string, { isSecret, secretMask }?: {
+        isSecret?: boolean | undefined;
+        secretMask?: string | undefined;
+    }): Exec;
+    /**
+     * Waits for `<delayInMs>` ms, e.g., 1000 ms. The exact delay may be a little longer
+     * than `<delayInMs>` but never shorter than that.
+     *
+     * @param {number} delayInMs - The delay in ms to wait for.
+     *
+     * @return {Executable}
+     */
+    waitFor(delayInMs: number): Executable;
+    /**
+    * closes the connection to the controlui-server`.
+    */
+    close(): void;
+}

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

@@ -0,0 +1,185 @@
+"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.UiControlClient = void 0;
+const test_case_dto_1 = require("../core/model/test-case-dto");
+const dsl_1 = require("./dsl");
+const http_client_got_1 = require("../utils/http/http-client-got");
+const ui_controller_client_1 = require("./ui-controller-client");
+const execution_runtime_1 = require("./execution-runtime");
+const inference_client_1 = require("./inference-client");
+const annotation_writer_1 = require("../core/annotation/annotation-writer");
+const logger_1 = require("../lib/logger");
+const test_case_result_dto_1 = require("../core/model/test-case-result-dto");
+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 getClientArgsWithDefaults = (clientArgs = {}) => (Object.assign({ uiControllerUrl: 'http://localhost:6769', inferenceServerUrl: 'https://inference.askui.com', annotationLevel: annotation_level_1.AnnotationLevel.DISABLED }, clientArgs));
+class UiControlClient extends dsl_1.FluentCommand {
+    constructor(httpClient, clientArgs) {
+        super();
+        this.httpClient = httpClient;
+        this.clientArgs = clientArgs;
+        this.secretText = undefined;
+    }
+    static build(clientArgs) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const analytics = new analytics_1.Analytics();
+            const analyticsHeaders = yield analytics.getAnalyticsHeaders();
+            const cas = getClientArgsWithDefaults(clientArgs);
+            const httpClient = new http_client_got_1.HttpClientGot(cas.credentials || (0, read_environment_credentials_1.envCredentials)(), analyticsHeaders);
+            return new UiControlClient(httpClient, cas);
+        });
+    }
+    get uiControllerClient() {
+        if (!this._uiControllerClient) {
+            this._uiControllerClient = new ui_controller_client_1.UiControllerClient(this.clientArgs.uiControllerUrl);
+        }
+        return this._uiControllerClient;
+    }
+    get inferenceClient() {
+        return new inference_client_1.InferenceClient(this.clientArgs.inferenceServerUrl, this.httpClient);
+    }
+    get executionRuntime() {
+        return new execution_runtime_1.ExecutionRuntime(this.uiControllerClient, this.inferenceClient);
+    }
+    annotateByDefault(testStepState, customElements = []) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if ((testStepState === test_case_result_dto_1.TestStepState.FAILED
+                && this.clientArgs.annotationLevel === annotation_level_1.AnnotationLevel.DISABLED)
+                || (testStepState === test_case_result_dto_1.TestStepState.PASSED
+                    && this.clientArgs.annotationLevel !== annotation_level_1.AnnotationLevel.ALL)) {
+                return;
+            }
+            yield this.annotate({
+                customElements,
+                fileNamePrefix: `${testStepState.toLowerCase()}_testStep_annotation`,
+            });
+        });
+    }
+    connect() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const connectionState = yield this.uiControllerClient.connect();
+            return connectionState;
+        });
+    }
+    annotate(annotationRequest = {}) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const annotation = yield this.executionRuntime.annotateImage(annotationRequest.imagePath, annotationRequest.customElements);
+            annotation_writer_1.AnnotationWriter.write(annotation.toHtml(), annotationRequest.outputPath, annotationRequest.fileNamePrefix);
+            return annotation;
+        });
+    }
+    annotateInteractively() {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                yield this.executionRuntime.annotateInteractively();
+            }
+            catch (err) {
+                logger_1.logger.error(err);
+            }
+        });
+    }
+    exec(instruction, customElementJson = []) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const customElements = yield test_case_dto_1.CustomElement.fromJsonListWithImagePathOrImage(customElementJson);
+            const { secretText } = this;
+            try {
+                yield this.executionRuntime.executeTestStep({
+                    instruction,
+                    customElements,
+                    secretText,
+                });
+                yield this.annotateByDefault(test_case_result_dto_1.TestStepState.PASSED, customElements);
+                return yield Promise.resolve();
+            }
+            catch (error) {
+                yield this.annotateByDefault(test_case_result_dto_1.TestStepState.FAILED, customElements);
+                return Promise.reject(new ui_control_client_error_1.UiControlClientError(`A problem occures while executing the instruction: ${instruction}. Reason ${error}`));
+            }
+        });
+    }
+    /**
+     * Types a text inside the filtered element.
+     *
+     * By default, the `text` is included in the logs and sent over to the askui Inference server to
+     * predict in which context the typing has to occur. You can exclude the `text` from the logs
+     * and the request to the askui Inference server setting `options.isSecret` to `true`.
+     * This should not change the quality of the prediction of the askui Inference server. In this
+     * case, `options.secretMask` is included in logs and sent over instead of the `text`.
+     *
+     * @param {string} text - A text to type.
+     * @param {Object} [options]
+     * @param {boolean} [options.isSecret = false] - If set to `true`, `text` is neither included in
+     *   logs of askui nor sent over to askui Inference for prediction.
+     * @param {string} [options.secretMask = '****'] - If `options.isSecret` is set to `true`, this
+     *   is included in logs and sent over to askui Inference for prediction instead of the `text`.
+     *
+     * @return {FluentFilters}
+     */
+    typeIn(text, { isSecret = false, secretMask = '****' } = {}) {
+        if (isSecret) {
+            this.secretText = text;
+            return super.typeIn(secretMask);
+        }
+        return super.typeIn(text);
+    }
+    /**
+     * Types a text at the current position.
+     *
+     * By default, the `text` is included in the logs and sent over to the askui Inference server to
+     * predict in which context the typing has to occur. You can exclude the `text` from the logs
+     * and the request to the askui Inference server setting `options.isSecret` to `true`.
+     * This should not change the quality of the prediction of the askui Inference server. In this
+     * case, `options.secretMask` is included in logs and sent over instead of the `text`.
+     *
+     * @param {string} text - A text to type.
+     * @param {Object} options
+     * @param {boolean} [options.isSecret = false] - If set to `true`, `text` is neither included in
+     *   logs of askui nor sent over to askui Inference for prediction.
+     * @param {string} [options.secretMask = '****'] - If `options.isSecret` is set to `true`, this
+     *   is included in logs and sent over to askui Inference for prediction instead of the `text`.
+     *
+     * @return {Exec}
+     */
+    type(text, { isSecret = false, secretMask = '****' } = {}) {
+        if (isSecret) {
+            this.secretText = text;
+            return super.type(secretMask);
+        }
+        return super.type(text);
+    }
+    /**
+     * Waits for `<delayInMs>` ms, e.g., 1000 ms. The exact delay may be a little longer
+     * than `<delayInMs>` but never shorter than that.
+     *
+     * @param {number} delayInMs - The delay in ms to wait for.
+     *
+     * @return {Executable}
+     */
+    // eslint-disable-next-line class-methods-use-this
+    waitFor(delayInMs) {
+        return {
+            exec() {
+                logger_1.logger.debug(`Wait for ${delayInMs} ms`);
+                return new Promise((resolve) => { setTimeout(() => resolve(), delayInMs); });
+            },
+        };
+    }
+    /**
+    * closes the connection to the controlui-server`.
+    */
+    close() {
+        this.uiControllerClient.close();
+    }
+}
+exports.UiControlClient = UiControlClient;

package/dist/cjs/execution/{client-connection-state.d.ts → ui-controller-client-connection-state.d.ts}

@@ -1,4 +1,4 @@
-export declare enum ClientConnectionState {
+export declare enum UiControllerClientConnectionState {
     NOT_CONNECTED = 0,
     CONNECTING = 1,
     CONNECTED = 2,

package/dist/cjs/execution/ui-controller-client-connection-state.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UiControllerClientConnectionState = void 0;
+var UiControllerClientConnectionState;
+(function (UiControllerClientConnectionState) {
+    UiControllerClientConnectionState[UiControllerClientConnectionState["NOT_CONNECTED"] = 0] = "NOT_CONNECTED";
+    UiControllerClientConnectionState[UiControllerClientConnectionState["CONNECTING"] = 1] = "CONNECTING";
+    UiControllerClientConnectionState[UiControllerClientConnectionState["CONNECTED"] = 2] = "CONNECTED";
+    UiControllerClientConnectionState[UiControllerClientConnectionState["ERROR"] = 3] = "ERROR";
+})(UiControllerClientConnectionState = exports.UiControllerClientConnectionState || (exports.UiControllerClientConnectionState = {}));

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

@@ -0,0 +1,27 @@
+import { CredentialArgs } from '../utils/http/credentials';
+import { AnnotationLevel } from './annotation-level';
+/**
+ * Configuration options for the askui UI Control Client
+ *
+ * @param {string} uiControllerUrl - Default: http://localhost:6769
+ * The adress of the askui UI Controller server.
+ * @param {string} inferenceClientUrl - Default: https://inference.askui.com`
+ * Address of the askui Inference server.
+ * @param {AnnotationLevel} annotationLevel - Default: AnnotationLevel.DISABLED
+ * Usage of annotate command
+ * after execution of test steps.
+ * You have three options: `DISABLED`, `ON_FAILURE`, `ALL`.
+ * @param {CredentialArgs} credentials - We need to provide credentials for
+ * the authentication of the askui Inference Server.
+ */
+export interface ClientArgs {
+    readonly uiControllerUrl?: string;
+    readonly inferenceServerUrl?: string;
+    readonly annotationLevel?: AnnotationLevel;
+    readonly credentials?: CredentialArgs;
+}
+export interface ClientArgsWithDefaults extends ClientArgs {
+    readonly uiControllerUrl: string;
+    readonly inferenceServerUrl: string;
+    readonly annotationLevel: AnnotationLevel;
+}

package/dist/cjs/execution/{control-your-ui-client.d.ts → ui-controller-client.d.ts}

@@ -2,21 +2,21 @@ import WebSocket from 'ws';
 import { DetectedElement } from '../core/model/annotation-result/detected-element';
 import { CaptureScreenshotResponse, ControlResponse, StartRecordingResponse, StopRecordingResponse, ReadRecordingPartResponse, InteractiveAnnotationResponse, GetProcessPidResponse } from '../core/runner-protocol';
 import { ControlCommand } from '../core/ui-control-commands';
-import { ClientConnectionState } from './client-connection-state';
-export declare class ControlYourUiClient {
-    controlServerUrl: string;
+import { UiControllerClientConnectionState } from './ui-controller-client-connection-state';
+export declare class UiControllerClient {
+    url: string;
     private static readonly EMPTY_REJECT;
     private static readonly EMPTY_RESOLVE;
     private static readonly REQUEST_TIMEOUT_IN_MS;
     ws: WebSocket;
-    connectionState: ClientConnectionState;
+    connectionState: UiControllerClientConnectionState;
     private timeout?;
     private currentReject;
     private currentResolve;
-    constructor(controlServerUrl: string);
+    constructor(url: string);
     private clearResponse;
     private onMessage;
-    connect(): Promise<ClientConnectionState>;
+    connect(): Promise<UiControllerClientConnectionState>;
     close(): void;
     private sendAndReceive;
     private send;

package/dist/cjs/execution/{control-your-ui-client.js → ui-controller-client.js}

@@ -3,23 +3,23 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.ControlYourUiClient = void 0;
+exports.UiControllerClient = void 0;
 const ws_1 = __importDefault(require("ws"));
 const runner_protocol_1 = require("../core/runner-protocol");
 const logger_1 = require("../lib/logger");
-const client_connection_state_1 = require("./client-connection-state");
+const ui_controller_client_connection_state_1 = require("./ui-controller-client-connection-state");
 const read_recording_response_stream_handler_1 = require("./read-recording-response-stream-handler");
-const client_error_1 = require("./client-error");
-class ControlYourUiClient {
-    constructor(controlServerUrl) {
-        this.controlServerUrl = controlServerUrl;
-        this.connectionState = client_connection_state_1.ClientConnectionState.NOT_CONNECTED;
-        this.currentReject = ControlYourUiClient.EMPTY_REJECT;
-        this.currentResolve = ControlYourUiClient.EMPTY_RESOLVE;
+const ui_control_client_error_1 = require("./ui-control-client-error");
+class UiControllerClient {
+    constructor(url) {
+        this.url = url;
+        this.connectionState = ui_controller_client_connection_state_1.UiControllerClientConnectionState.NOT_CONNECTED;
+        this.currentReject = UiControllerClient.EMPTY_REJECT;
+        this.currentResolve = UiControllerClient.EMPTY_RESOLVE;
     }
     clearResponse() {
-        this.currentReject = ControlYourUiClient.EMPTY_REJECT;
-        this.currentResolve = ControlYourUiClient.EMPTY_RESOLVE;
+        this.currentReject = UiControllerClient.EMPTY_REJECT;
+        this.currentResolve = UiControllerClient.EMPTY_RESOLVE;
     }
     onMessage(data) {
         clearTimeout(this.timeout);
@@ -36,24 +36,24 @@ class ControlYourUiClient {
         this.clearResponse();
     }
     connect() {
-        this.connectionState = client_connection_state_1.ClientConnectionState.CONNECTING;
+        this.connectionState = ui_controller_client_connection_state_1.UiControllerClientConnectionState.CONNECTING;
         return new Promise((resolve, reject) => {
             try {
-                this.ws = new ws_1.default(this.controlServerUrl);
+                this.ws = new ws_1.default(this.url);
                 this.ws.on('message', (data) => { this.onMessage(data); });
                 this.ws.on('open', () => {
-                    this.connectionState = client_connection_state_1.ClientConnectionState.CONNECTED;
+                    this.connectionState = ui_controller_client_connection_state_1.UiControllerClientConnectionState.CONNECTED;
                     resolve(this.connectionState);
                 });
                 this.ws.on('error', (error) => {
-                    this.connectionState = client_connection_state_1.ClientConnectionState.ERROR;
-                    reject(new client_error_1.ControlUiClientError(`Connection to Control UI Server cannot be established,
-          Probably it was not started. Makse sure you started the server with this 
-          Url ${this.controlServerUrl}. Error message  ${error.message}`));
+                    this.connectionState = ui_controller_client_connection_state_1.UiControllerClientConnectionState.ERROR;
+                    reject(new ui_control_client_error_1.UiControlClientError(`Connection to UI Controller cannot be established,
+          Probably it was not started. Makse sure you started UI Controller with this 
+          Url ${this.url}. Error message  ${error.message}`));
                 });
             }
             catch (error) {
-                reject(new client_error_1.ControlUiClientError(`Connection to Control UI Server cannot be established. Reason: ${error}`));
+                reject(new ui_control_client_error_1.UiControlClientError(`Connection to UI Controller cannot be established. Reason: ${error}`));
             }
         });
     }
@@ -61,21 +61,21 @@ class ControlYourUiClient {
         var _a;
         (_a = this.ws) === null || _a === void 0 ? void 0 : _a.close();
     }
-    sendAndReceive(msg, requestTimeout = ControlYourUiClient.REQUEST_TIMEOUT_IN_MS) {
+    sendAndReceive(msg, requestTimeout = UiControllerClient.REQUEST_TIMEOUT_IN_MS) {
         return new Promise((resolve, reject) => {
             this.currentResolve = resolve;
             this.currentReject = reject;
             try {
                 this.send(msg, requestTimeout);
-                this.timeout = setTimeout(() => this.currentReject(`Request to Control UI Server timed out.
-          it seems that the server is down, Please make sure the server is up`), ControlYourUiClient.REQUEST_TIMEOUT_IN_MS);
+                this.timeout = setTimeout(() => this.currentReject(`Request to UI Controller timed out.
+          It seems that the UI Controller is not running. Please, make sure that it is running when executing tests.`), UiControllerClient.REQUEST_TIMEOUT_IN_MS);
             }
             catch (error) {
-                this.currentReject(`The communication to the ControlUI Server is broken. Reason: ${error}`);
+                this.currentReject(`The communication to the UI Controller is broken. Reason: ${error}`);
             }
         });
     }
-    send(msg, _requestTimeout = ControlYourUiClient.REQUEST_TIMEOUT_IN_MS) {
+    send(msg, _requestTimeout = UiControllerClient.REQUEST_TIMEOUT_IN_MS) {
         if (!this.currentReject || !this.currentResolve) {
             throw Error('Request is not finished! It is not possible to have multiple requests at the same time.');
         }
@@ -113,7 +113,7 @@ class ControlYourUiClient {
         return this.sendAndReceive(new runner_protocol_1.ControlRequest(controlCommand));
     }
 }
-exports.ControlYourUiClient = ControlYourUiClient;
-ControlYourUiClient.EMPTY_REJECT = (_reason) => { };
-ControlYourUiClient.EMPTY_RESOLVE = (_value) => { };
-ControlYourUiClient.REQUEST_TIMEOUT_IN_MS = 30000;
+exports.UiControllerClient = UiControllerClient;
+UiControllerClient.EMPTY_REJECT = (_reason) => { };
+UiControllerClient.EMPTY_RESOLVE = (_value) => { };
+UiControllerClient.REQUEST_TIMEOUT_IN_MS = 30000;

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

@@ -7,6 +7,7 @@ exports.init = void 0;
 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 createProgram = () => {
     const program = new commander_1.Command('askui');
     program.usage('<command> [options]');
@@ -14,7 +15,7 @@ const createProgram = () => {
 };
 function copyExampleProject() {
     const exampleProjectPath = path_1.default.join('example_projects_templates', 'typescript_jest');
-    fs_extra_1.default.copySync(path_1.default.join(__dirname, '..', '..', exampleProjectPath), '.');
+    fs_extra_1.default.copySync(path_1.default.join((0, path_2.getPathToNodeModulesRoot)(), exampleProjectPath), '.');
 }
 function init(argv) {
     const args = argv || process.argv;

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

@@ -8,6 +8,7 @@ const fs_1 = __importDefault(require("fs"));
 const got_1 = __importDefault(require("got"));
 const os_1 = __importDefault(require("os"));
 const path_1 = __importDefault(require("path"));
+const path_2 = require("../utils/path");
 const logger_1 = require("./logger");
 var SupportedPlatform;
 (function (SupportedPlatform) {
@@ -16,9 +17,9 @@ var SupportedPlatform;
     SupportedPlatform["WIN32"] = "win32";
 })(SupportedPlatform || (SupportedPlatform = {}));
 const binarySubPathsByPlatform = {
-    linux: ['linux', 'controlui-server.AppImage'],
-    darwin: ['darwin', 'controlui-server.dmg'],
-    win32: ['windows', 'controlui-server.exe'],
+    linux: ['linux', 'askui-ui-controller.AppImage'],
+    darwin: ['darwin', 'askui-ui-controller.dmg'],
+    win32: ['windows', 'askui-ui-controller.exe'],
 };
 function isSupportedPlatform(value) {
     return Object.values(SupportedPlatform).includes(value);
@@ -32,14 +33,14 @@ function platform() {
 }
 exports.platform = platform;
 function buildBinaryNotAvailbleError(binaryVersion) {
-    return new Error(`It seems that the askui server binary version "${binaryVersion}" for your system "${platform()} ${os_1.default.arch}" is not availble, Please contact as at info@askui.com for more information`);
+    return new Error(`It seems that the UI Controller version "${binaryVersion}" for your system "${platform()} ${os_1.default.arch}" is not availble, Please contact as at info@askui.com for more information`);
 }
 function getBinaryPath(version) {
-    return path_1.default.join(__dirname, '..', '..', 'release', version, ...binarySubPathsByPlatform[platform()]);
+    return path_1.default.join((0, path_2.getPathToNodeModulesRoot)(), 'release', version, ...binarySubPathsByPlatform[platform()]);
 }
 exports.getBinaryPath = getBinaryPath;
 function getBinaryDownloadUrl(binaryVersion) {
-    const baseUrl = `https://askui-public.s3.eu-central-1.amazonaws.com/releases/controlui-server/${binaryVersion}`;
+    const baseUrl = `https://askui-public.s3.eu-central-1.amazonaws.com/releases/askui-ui-controller/${binaryVersion}`;
     const arch = os_1.default.arch();
     return `${baseUrl}/${platform()}/${arch}/${binarySubPathsByPlatform[platform()][1]}`;
 }
@@ -48,7 +49,7 @@ function downloadServerBinaries(binaryVersion) {
         const url = getBinaryDownloadUrl(binaryVersion);
         const binaryOutputPath = getBinaryPath(binaryVersion);
         const binaryFolder = path_1.default.dirname(binaryOutputPath);
-        logger_1.logger.info(`Start downloading askui server binary version "${binaryVersion}"`);
+        logger_1.logger.info(`Start downloading UI Controller version "${binaryVersion}"`);
         if (!(fs_1.default.existsSync(binaryFolder))) {
             fs_1.default.mkdirSync(binaryFolder, { recursive: true });
         }
@@ -65,8 +66,8 @@ function downloadServerBinaries(binaryVersion) {
             reject(new Error('oops, an error during the downloaded occurred, try again with fresh install'));
         })
             .on('finish', () => {
-            logger_1.logger.info(`askui server binary version ${binaryVersion} for your system "${platform()} ${os_1.default.arch}" was downloaded`);
-            logger_1.logger.debug(`Binary of Control UI Server is located at "${binaryOutputPath}".`);
+            logger_1.logger.info(`UI Controller version ${binaryVersion} for your system "${platform()} ${os_1.default.arch}" was downloaded`);
+            logger_1.logger.debug(`Binary of UI Controller is located at "${binaryOutputPath}".`);
             resolve();
         });
         downloadStream.pipe(fileWriterStream);

package/dist/cjs/lib/index.d.ts

@@ -1,4 +1,4 @@
 export { UnkownError } from './unkown-error';
 export { TimeoutError } from './timeout-error';
-export { AskuiControlServer } from './askui-control-server';
+export { UiController } from './ui-controller';
 export { logger } from './logger';

package/dist/cjs/lib/index.js

@@ -1,11 +1,11 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.logger = exports.AskuiControlServer = exports.TimeoutError = exports.UnkownError = void 0;
+exports.logger = exports.UiController = exports.TimeoutError = exports.UnkownError = void 0;
 var unkown_error_1 = require("./unkown-error");
 Object.defineProperty(exports, "UnkownError", { enumerable: true, get: function () { return unkown_error_1.UnkownError; } });
 var timeout_error_1 = require("./timeout-error");
 Object.defineProperty(exports, "TimeoutError", { enumerable: true, get: function () { return timeout_error_1.TimeoutError; } });
-var askui_control_server_1 = require("./askui-control-server");
-Object.defineProperty(exports, "AskuiControlServer", { enumerable: true, get: function () { return askui_control_server_1.AskuiControlServer; } });
+var ui_controller_1 = require("./ui-controller");
+Object.defineProperty(exports, "UiController", { enumerable: true, get: function () { return ui_controller_1.UiController; } });
 var logger_1 = require("./logger");
 Object.defineProperty(exports, "logger", { enumerable: true, get: function () { return logger_1.logger; } });

package/dist/cjs/lib/libfuse-error.d.ts

@@ -0,0 +1,2 @@
+export declare class LibfuseError extends Error {
+}

package/dist/cjs/lib/libfuse-error.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LibfuseError = void 0;
+class LibfuseError extends Error {
+}
+exports.LibfuseError = LibfuseError;

package/dist/cjs/lib/logger.js

@@ -23,7 +23,7 @@ const stream = (0, pino_pretty_1.default)({
 const defaultLogLevel = 'info';
 const pinoLevel = isProcessEnvLogLevelValid() ? process.env['LOG_LEVEL'] : defaultLogLevel;
 const logger = (0, pino_1.default)({
-    name: 'askuiClient',
+    name: 'askuiUiControlClient',
     level: pinoLevel,
     customLevels: {
         verbose: 5,

package/dist/cjs/lib/timeout-error.d.ts

@@ -1,4 +1,2 @@
 export declare class TimeoutError extends Error {
-    contructorName: string;
-    constructor(message: string);
 }

package/dist/cjs/lib/timeout-error.js

@@ -2,10 +2,5 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.TimeoutError = void 0;
 class TimeoutError extends Error {
-    constructor(message) {
-        super(message);
-        this.contructorName = this.constructor.name;
-        this.name = this.contructorName;
-    }
 }
 exports.TimeoutError = TimeoutError;

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

@@ -0,0 +1,47 @@
+import { LogLevels } from '../shared/log-levels';
+/**
+ * Configuration options for the askui UI Controller
+ *
+ * @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'`
+ *  Choose the version of the askui UI Controller Server.
+ * @param {number} port - Default: `6769`
+ * The port the askui UI Controller is running on.
+ * @param {string} host - Default: `'127.0.0.1'`
+ * The host the askui UI Controller is running on.
+ * @param {boolean} minimize - Default: `true`
+ * askui UI Controller will be started as minimized window.
+ * @param {boolean} overWriteBinary - Default: `false`
+ * Download the provided Version of askui UI Controller.
+ * If a version is already downloaded. This version will be overwritten
+ * @param {LogLevels} logLevel - Default: `'debug'`
+ * You can use different types of Log Level.
+ * Options: "fatal", "error", "warn", "info", "debug", "trace", "silent", "verbose".
+ * @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.
+ */
+export interface UiControllerArgs {
+    readonly display?: number;
+    readonly binaryVersion?: string;
+    readonly port?: number;
+    readonly host?: string;
+    readonly minimize?: boolean;
+    readonly overWriteBinary?: boolean;
+    readonly logLevel?: LogLevels;
+    readonly logFilePath?: string;
+}
+export interface UiControllerArgsWithDefaults extends UiControllerArgs {
+    readonly display: number;
+    readonly binaryVersion: string;
+    readonly overWriteBinary: boolean;
+    readonly port: number;
+    readonly host: string;
+    readonly logLevel?: LogLevels;
+}
+export declare function createArgsWithDefaults(args?: UiControllerArgs): UiControllerArgsWithDefaults;
+export declare function createCliFlagsFromArgs(args: UiControllerArgsWithDefaults): string[];