@mablhq/mabl-cli 1.61.8 → 2.0.3

package/upload/index.js

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UploadClient = void 0;
+var upload_service_client_nodejs_1 = require("@mablhq/upload-service-client-nodejs");
+Object.defineProperty(exports, "UploadClient", { enumerable: true, get: function () { return upload_service_client_nodejs_1.UploadClient; } });

package/util/FileCache.js

@@ -0,0 +1,180 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FileCache = void 0;
+const crc32c_1 = require("@aws-crypto/crc32c");
+const fs_1 = require("fs");
+const promises_1 = require("fs/promises");
+const node_path_1 = require("node:path");
+const cachedir_1 = __importDefault(require("cachedir"));
+const env_1 = require("../env/env");
+const loggingProvider_1 = require("../providers/logging/loggingProvider");
+const DEFAULT_READ_BUFFER_SIZE_BYTES = 8 * 1024 * 1024;
+class File {
+    constructor(directory, name) {
+        this.path = (0, node_path_1.resolve)((0, node_path_1.join)(directory, name));
+        this.stats = (0, fs_1.statSync)(this.path);
+    }
+    get createdTimeMillis() {
+        return this.stats.ctimeMs;
+    }
+    delete() {
+        (0, fs_1.rmSync)(this.path, { force: true, recursive: this.isDirectory });
+    }
+    get isDirectory() {
+        return this.stats.isDirectory();
+    }
+}
+class FileCache {
+    constructor({ cacheName, maximumCachedFiles, maximumCachedFileAgeMinutes, readBufferSizeBytes, }) {
+        this.cacheName = cacheName;
+        this.cacheDirectoryPath = (0, node_path_1.resolve)((0, node_path_1.join)((0, cachedir_1.default)(env_1.CONF_FILE_PROJECT_NAME), cacheName));
+        this.maximumCachedFiles = maximumCachedFiles;
+        this.maximumCachedFileAgeMinutes = maximumCachedFileAgeMinutes;
+        this.readBufferSizeBytes =
+            readBufferSizeBytes !== null && readBufferSizeBytes !== void 0 ? readBufferSizeBytes : DEFAULT_READ_BUFFER_SIZE_BYTES;
+    }
+    async performCacheCleanup() {
+        if (!(await this.directoryExists(this.cacheDirectoryPath))) {
+            return;
+        }
+        const nowMillis = Date.now();
+        try {
+            const files = (await (0, promises_1.readdir)(this.cacheDirectoryPath))
+                .map((name) => new File(this.cacheDirectoryPath, name))
+                .filter((file) => {
+                if (this.maximumCachedFileAgeMinutes &&
+                    (nowMillis - file.createdTimeMillis) / 1000 / 60 >
+                        this.maximumCachedFileAgeMinutes) {
+                    loggingProvider_1.logger.info(`Deleting expired cache ${file.isDirectory ? 'directory' : 'file'} ${file.path}`);
+                    file.delete();
+                    return false;
+                }
+                return true;
+            })
+                .sort((left, right) => right.createdTimeMillis - left.createdTimeMillis);
+            if (this.maximumCachedFiles && files.length > this.maximumCachedFiles) {
+                loggingProvider_1.logger.info(`Deleting the oldest ${files.length - this.maximumCachedFiles} file(s) in ${this.cacheName} cache`);
+                files.slice(this.maximumCachedFiles).forEach((file) => {
+                    loggingProvider_1.logger.info(`Deleting cache ${file.isDirectory ? 'directory' : 'file'} ${file.path}`);
+                    file.delete();
+                });
+            }
+        }
+        catch (error) {
+            loggingProvider_1.logger.error(`Error performing cache cleanup on ${this.cacheDirectoryPath}`, error);
+        }
+    }
+    async getOrCreateFile(name, getReader, metadata) {
+        const path = this.getCacheFilePath(name);
+        await this.performCacheCleanup();
+        if (await this.cachedFileIsValid(path, metadata)) {
+            return path;
+        }
+        const { crc32cHex: writtenCrc32cHex, sizeBytes: writtenSizeBytes } = await this.write(await getReader(), path, metadata === null || metadata === void 0 ? void 0 : metadata.sizeBytes);
+        if (metadata) {
+            if (writtenSizeBytes !== metadata.sizeBytes) {
+                throw new Error(`Expected ${metadata.sizeBytes}b but received ${writtenSizeBytes}b`);
+            }
+            if (writtenCrc32cHex !== metadata.crc32cHex) {
+                throw new Error(`Expected checksum ${metadata.crc32cHex} but computed ${writtenCrc32cHex}`);
+            }
+        }
+        if (!(await this.cachedFileIsValid(path, metadata))) {
+            throw new Error(`Downloaded cache file ${path} failed verification`);
+        }
+        return path;
+    }
+    async directoryExists(path) {
+        try {
+            return (await (0, promises_1.stat)(path)).isDirectory();
+        }
+        catch (error) {
+            return false;
+        }
+    }
+    async fileExists(path) {
+        try {
+            return (await (0, promises_1.stat)(path)).isFile();
+        }
+        catch (error) {
+            return false;
+        }
+    }
+    async cachedFileIsValid(path, metadata) {
+        if (!(await this.fileExists(path))) {
+            return false;
+        }
+        if (metadata) {
+            loggingProvider_1.logger.info(`Verifying integrity of cache file ${path}`);
+            const actualSizeBytes = (await (0, promises_1.stat)(path)).size;
+            if (actualSizeBytes !== metadata.sizeBytes) {
+                loggingProvider_1.logger.warn(`Expected cache file at ${path} to have size [${metadata.sizeBytes}b] but was [${actualSizeBytes}b]`);
+                return false;
+            }
+            const actualCrc32cHex = await this.computeCrc32cHex(path);
+            if (actualCrc32cHex !== metadata.crc32cHex) {
+                loggingProvider_1.logger.warn(`Expected cache file at ${path} to have checksum [${metadata.crc32cHex}] but was [${actualCrc32cHex}]}`);
+                return false;
+            }
+        }
+        return true;
+    }
+    getCacheFilePath(relativePath) {
+        return (0, node_path_1.resolve)((0, node_path_1.join)(this.cacheDirectoryPath, relativePath));
+    }
+    async write(reader, destination, expectedSizeBytes) {
+        const destinationDirectory = (0, node_path_1.dirname)(destination);
+        if (!(await this.directoryExists(destinationDirectory))) {
+            await (0, promises_1.mkdir)(destinationDirectory, { recursive: true });
+        }
+        const fd = await (0, promises_1.open)(destination, 'w');
+        const writeStream = fd.createWriteStream({ autoClose: true });
+        const metadata = await new Promise((resolve, reject) => {
+            const crc32c = new crc32c_1.Crc32c();
+            let sizeBytes = 0;
+            let percentageComplete = 0;
+            writeStream.on('error', (error) => reject(error));
+            writeStream.on('close', () => resolve({ crc32cHex: crc32c.digest().toString(16), sizeBytes }));
+            reader.on('error', (error) => reject(error));
+            reader.on('end', () => writeStream.close());
+            reader.on('data', (chunk) => {
+                crc32c.update(chunk);
+                sizeBytes += chunk.byteLength;
+                if (expectedSizeBytes) {
+                    const newPercentageComplete = Math.round((sizeBytes / expectedSizeBytes) * 100);
+                    if (newPercentageComplete % 10 === 0 &&
+                        newPercentageComplete > percentageComplete) {
+                        percentageComplete = newPercentageComplete;
+                        loggingProvider_1.logger.info(`Downloaded ${sizeBytes} of ${expectedSizeBytes} bytes (${percentageComplete}% complete)`);
+                    }
+                }
+            });
+            reader.pipe(writeStream);
+        });
+        await this.performCacheCleanup();
+        return metadata;
+    }
+    async computeCrc32cHex(path) {
+        const fd = await (0, promises_1.open)(path, 'r');
+        const crc32c = new crc32c_1.Crc32c();
+        let totalBytesRead = 0;
+        while (true) {
+            const { buffer, bytesRead: chunkSizeBytes } = await fd.read({
+                buffer: Buffer.alloc(this.readBufferSizeBytes),
+                length: this.readBufferSizeBytes,
+                position: totalBytesRead,
+            });
+            if (chunkSizeBytes === 0) {
+                break;
+            }
+            totalBytesRead += chunkSizeBytes;
+            const chunk = buffer.subarray(0, chunkSizeBytes);
+            crc32c.update(chunk);
+        }
+        return crc32c.digest().toString(16);
+    }
+}
+exports.FileCache = FileCache;

package/util/Lazy.js

@@ -0,0 +1,90 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Lazy = void 0;
+class Lazy {
+    constructor(initializer) {
+        this.initializer = initializer;
+    }
+    apply(action) {
+        return action(this.instance);
+    }
+    get instance() {
+        if (!this.value) {
+            this.value = this.initializer();
+        }
+        return this.value;
+    }
+    get isInitialized() {
+        return !!this.value;
+    }
+    map(mapper) {
+        return new Lazy(() => this.apply(mapper));
+    }
+    get maybe() {
+        return this.value;
+    }
+    reset() {
+        this.value = undefined;
+    }
+    withValue(consumer) {
+        consumer(this.instance);
+    }
+    withValueAsync(consumer) {
+        return this.apply(consumer);
+    }
+    static from(instance) {
+        return new Lazy(() => instance);
+    }
+    static of(initializer) {
+        return new Lazy(initializer);
+    }
+    static proxy(initializer) {
+        const lazy = Lazy.of(initializer);
+        return new Proxy(lazy, new LazyProxy(lazy));
+    }
+}
+exports.Lazy = Lazy;
+class LazyProxy {
+    constructor(lazy) {
+        this.lazy = lazy;
+    }
+    apply(target, _thisArg, args) {
+        return Reflect.apply(target, this.lazy.instance, args);
+    }
+    construct(target, argArray, _newTarget) {
+        return Reflect.construct(target, argArray, this.lazy.instance.constructor);
+    }
+    defineProperty(_target, property, attributes) {
+        return Reflect.defineProperty(this.lazy.instance, property, attributes);
+    }
+    deleteProperty(_target, p) {
+        return Reflect.deleteProperty(this.lazy.instance, p);
+    }
+    get(_target, p, receiver) {
+        return Reflect.get(this.lazy.instance, p, receiver);
+    }
+    getOwnPropertyDescriptor(_target, p) {
+        return Reflect.getOwnPropertyDescriptor(this.lazy.instance, p);
+    }
+    getPrototypeOf(_target) {
+        return Reflect.getPrototypeOf(this.lazy.instance);
+    }
+    has(_target, p) {
+        return Reflect.has(this.lazy.instance, p);
+    }
+    isExtensible(_target) {
+        return Reflect.isExtensible(this.lazy.instance);
+    }
+    ownKeys(_target) {
+        return Reflect.ownKeys(this.lazy.instance);
+    }
+    preventExtensions(_target) {
+        return Reflect.preventExtensions(this.lazy.instance);
+    }
+    set(_target, p, newValue, receiver) {
+        return Reflect.set(this.lazy.instance, p, newValue, receiver);
+    }
+    setPrototypeOf(_target, v) {
+        return Reflect.setPrototypeOf(this.lazy.instance, v);
+    }
+}

package/util/MobileAppFileCache.js

@@ -0,0 +1,102 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MobileAppFileCache = void 0;
+const path_1 = require("path");
+const stream_1 = require("stream");
+const promises_1 = require("fs/promises");
+const mablApi_1 = require("../mablApi");
+const util_1 = require("../core/util");
+const FileCache_1 = require("./FileCache");
+const loggingProvider_1 = require("../providers/logging/loggingProvider");
+const MOBILE_APP_FILE_CACHE_DIRECTORY = 'mobile-app-files';
+const DEFAULT_MAX_MOBILE_APP_FILES = 10;
+const DEFAULT_MAX_MOBILE_APP_FILE_AGE_MINUTES = 60 * 24;
+const MOBILE_APP_FILE_IMMUTABLE_FIELDS = [
+    'content_type',
+    'crc32c_hex',
+    'created_by_id',
+    'created_time',
+    'extension',
+    'id',
+    'name',
+    'platform',
+    'size',
+    'workspace_id',
+];
+const MOBILE_APP_FILE_IMMUTABLE_FIELD_SET = new Set(MOBILE_APP_FILE_IMMUTABLE_FIELDS);
+class MobileAppFileCache extends FileCache_1.FileCache {
+    constructor(options) {
+        var _a, _b;
+        super({
+            ...options,
+            cacheName: MOBILE_APP_FILE_CACHE_DIRECTORY,
+            maximumCachedFiles: (_a = options === null || options === void 0 ? void 0 : options.maximumCachedFiles) !== null && _a !== void 0 ? _a : DEFAULT_MAX_MOBILE_APP_FILES,
+            maximumCachedFileAgeMinutes: (_b = options === null || options === void 0 ? void 0 : options.maximumCachedFileAgeMinutes) !== null && _b !== void 0 ? _b : DEFAULT_MAX_MOBILE_APP_FILE_AGE_MINUTES,
+        });
+        this.mablApiClientPromise = (options === null || options === void 0 ? void 0 : options.mablApiClient)
+            ? Promise.resolve(options.mablApiClient)
+            : (0, util_1.getApiClient)();
+    }
+    async getMobileAppFileImmutableFields(id) {
+        const getReader = async () => {
+            const apiClient = await this.mablApiClientPromise;
+            const mobileAppFile = this.retainImmutableFields(await apiClient.getMobileAppFile(id));
+            return stream_1.Readable.from(Buffer.from(JSON.stringify(mobileAppFile, undefined, 0), 'utf-8'));
+        };
+        const path = await this.getOrCreateFile((0, path_1.join)(id, 'MobileAppFile.json'), getReader);
+        return JSON.parse((await (0, promises_1.readFile)(path)).toString());
+    }
+    async getMobileAppFile(id) {
+        const mobileAppFile = await this.getMobileAppFileImmutableFields(id);
+        const { crc32c_hex: crc32cHex, size: sizeBytes } = mobileAppFile;
+        const getReader = async () => {
+            loggingProvider_1.logger.info(`Downloading mobile app file ${id}`);
+            const apiClient = await this.mablApiClientPromise;
+            const { download_url: downloadUrl } = await apiClient.getMobileAppFile(id, true);
+            return (await apiClient.httpClient.get(downloadUrl, {
+                responseType: 'stream',
+            })).data;
+        };
+        const extension = this.getMobileAppFileExtension(mobileAppFile);
+        if (!extension) {
+            throw new Error(`Unable to determine file extension for mobile app file ${id}`);
+        }
+        const path = await this.getOrCreateFile((0, path_1.join)(id, `MobileAppFile.${extension}`), getReader, {
+            crc32cHex: crc32cHex,
+            sizeBytes: sizeBytes,
+        });
+        return { ...mobileAppFile, path };
+    }
+    retainImmutableFields(mobileAppFile) {
+        const immutableFields = { ...mobileAppFile };
+        Object.keys(immutableFields).forEach((field) => {
+            if (!MOBILE_APP_FILE_IMMUTABLE_FIELD_SET.has(field)) {
+                delete immutableFields[field];
+            }
+        });
+        return immutableFields;
+    }
+    getMobileAppFileExtension({ extension, id, name, platform, }) {
+        let resolvedExtension = extension;
+        if (!resolvedExtension && name) {
+            resolvedExtension = (0, path_1.extname)(name);
+        }
+        if (!resolvedExtension && platform) {
+            switch (platform) {
+                case mablApi_1.MobilePlatformEnum.Android:
+                    resolvedExtension = 'apk';
+                    break;
+                case mablApi_1.MobilePlatformEnum.Ios:
+                    resolvedExtension = 'app.zip';
+                    break;
+                default:
+                    throw new Error(`Mobile app file ${id} has unknown platform ${platform}`);
+            }
+        }
+        if (resolvedExtension === null || resolvedExtension === void 0 ? void 0 : resolvedExtension.startsWith('.')) {
+            resolvedExtension = resolvedExtension.substring(1);
+        }
+        return resolvedExtension;
+    }
+}
+exports.MobileAppFileCache = MobileAppFileCache;

package/util/RichPromise.js

@@ -1,4 +1,5 @@
 "use strict";
+var _a;
 Object.defineProperty(exports, "__esModule", { value: true });
 class RichPromise {
     constructor(chained) {
@@ -6,6 +7,7 @@ class RichPromise {
         this.resolved = false;
         this.rejecter = () => { };
         this.rejected = false;
+        this[_a] = 'promise';
         this.promise = new Promise((resolve, reject) => {
             this.resolver = resolve;
             this.rejecter = reject;
@@ -48,4 +50,4 @@ class RichPromise {
     }
 }
 exports.default = RichPromise;
-Symbol.toStringTag;
+_a = Symbol.toStringTag;

package/webdriver/index.js

@@ -0,0 +1,41 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getDriver = exports.getSessionInfo = exports.setSessionInfo = exports.initializeDriverInPage = void 0;
+const web2driver_1 = require("web2driver");
+let MABL_SESSION_CONFIG;
+let MABL_APPIUM_DRIVER;
+async function initializeDriverInPage(config) {
+    var _a, _b, _c, _d, _e;
+    const driver = await web2driver_1.Web2Driver.attachToSession(config.sessionId, {
+        protocol: (_a = config.protocol) !== null && _a !== void 0 ? _a : 'http',
+        hostname: (_b = config.hostname) !== null && _b !== void 0 ? _b : 'localhost',
+        port: (_c = config.port) !== null && _c !== void 0 ? _c : 4723,
+        path: (_d = config.path) !== null && _d !== void 0 ? _d : '/',
+    }, config.capabilities, (_e = config.isW3C) !== null && _e !== void 0 ? _e : true);
+    return driver;
+}
+exports.initializeDriverInPage = initializeDriverInPage;
+function setSessionInfo(config) {
+    MABL_SESSION_CONFIG = config;
+}
+exports.setSessionInfo = setSessionInfo;
+function getSessionInfo() {
+    return MABL_SESSION_CONFIG;
+}
+exports.getSessionInfo = getSessionInfo;
+async function getDriver() {
+    if (!MABL_APPIUM_DRIVER) {
+        MABL_APPIUM_DRIVER = (await initializeDriverInPage(MABL_SESSION_CONFIG));
+    }
+    return MABL_APPIUM_DRIVER;
+}
+exports.getDriver = getDriver;
+window.mabl = {
+    mobile: {
+        initializeDriverInPage,
+        setSessionInfo,
+        getSessionInfo,
+        getDriver,
+    },
+    ...window._mabl,
+};