@mablhq/playwright-tools 2.49.1

package/browserLauncher/playwrightBrowserLauncher/playwrightPage.js

@@ -0,0 +1,377 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PlaywrightPage = void 0;
+const events_1 = __importDefault(require("events"));
+const promises_1 = require("fs/promises");
+const browserLauncher_1 = require("../browserLauncher");
+const playwright = __importStar(require("playwright"));
+const playwrightHttpResponse_1 = require("./playwrightHttpResponse");
+const playwrightHttpRequest_1 = require("./playwrightHttpRequest");
+const playwrightFrame_1 = require("./playwrightFrame");
+const playwrightDom_1 = require("./playwrightDom");
+const utils_1 = require("../utils");
+const wrappers_1 = require("./wrappers");
+const logUtils_1 = require("../../util/logUtils");
+const uuid = __importStar(require("uuid"));
+const path = require("path");
+class PlaywrightPage extends events_1.default {
+    constructor(page, browser, delegate) {
+        var _a;
+        super();
+        this.page = page;
+        this.browser = browser;
+        this.delegate = delegate;
+        this.playwrightFrames = new Map();
+        this.requestListeners = [];
+        const guid = page._guid;
+        this.pageId = (_a = delegate.getTargetId()) !== null && _a !== void 0 ? _a : guid;
+        page.off('dialog', this.acceptDialogs);
+        page.on('dialog', this.acceptDialogs);
+        page.on('close', () => {
+            this.browser.onPageClose(this);
+        });
+        page.on('download', async (download) => {
+            var _a, _b;
+            const guid = uuid.v4();
+            const downloadSize = (_b = (_a = (await download.createReadStream())) === null || _a === void 0 ? void 0 : _a.readableLength) !== null && _b !== void 0 ? _b : 0;
+            browser.emit(browserLauncher_1.BrowserEvent.DownloadWillBegin, {
+                guid,
+                suggestedFilename: download.suggestedFilename(),
+                url: download.url(),
+            });
+            browser.emit(browserLauncher_1.BrowserEvent.DownloadProgress, {
+                guid,
+                totalBytes: downloadSize,
+                receivedBytes: downloadSize,
+                state: 'completed',
+            });
+            if (this.browser.browserDelegate.downloadsUsingGuids()) {
+                await download.saveAs(path.join(this.browser.getDownloadDirectory(), download.suggestedFilename()));
+            }
+        });
+    }
+    addRequestListener(listener) {
+        if (this.requestListeners.length === 0) {
+            void this.page.route('**/*', async (route) => {
+                const listeners = this.requestListeners;
+                if (listeners.length === 0) {
+                    void route.continue();
+                    return;
+                }
+                const request = new playwrightHttpRequest_1.PlaywrightHttpRequest(this, route.request(), route);
+                for (const listener of listeners) {
+                    await listener(request);
+                    if (request.wasIntercepted()) {
+                        return;
+                    }
+                }
+                await route.continue();
+            });
+        }
+        this.requestListeners.push(listener);
+    }
+    createCDPSession() {
+        return this.delegate.createCDPSession();
+    }
+    async waitForInitialization() {
+        await this.delegate.waitForInitialization();
+        this.openerPage = await (0, utils_1.mapIfNotNull)(await this.page.opener(), (page) => this.browser.getOrCreatePage(page));
+        if (this.browser.disableFocusEmulation) {
+            await this.delegate.setFocusEmulationEnabled(false);
+        }
+    }
+    on(event, listener) {
+        this.wireEvents(event);
+        super.on(event, listener);
+        return this;
+    }
+    once(event, listener) {
+        this.wireEvents(event);
+        super.once(event, listener);
+        return this;
+    }
+    wireEvents(event) {
+        try {
+            if (event === browserLauncher_1.PageEvent.RequestWillBeSentExtraInfo &&
+                !this.listenerCount(event)) {
+                this.getCDPSession().on('Network.requestWillBeSentExtraInfo', (event) => {
+                    this.emit(browserLauncher_1.PageEvent.RequestWillBeSentExtraInfo, event);
+                });
+            }
+            if (event === browserLauncher_1.PageEvent.Response && !this.listenerCount(event)) {
+                this.page.on('response', (event) => {
+                    this.emit(browserLauncher_1.PageEvent.Response, new playwrightHttpResponse_1.PlaywrightHttpResponse(this, event));
+                });
+            }
+            if (event === browserLauncher_1.PageEvent.FrameNavigated && !this.listenerCount(event)) {
+                this.page.on('framenavigated', (frame) => {
+                    this.emit(browserLauncher_1.PageEvent.FrameNavigated, this.getOrCreateFrame(frame));
+                });
+            }
+            if (event === browserLauncher_1.PageEvent.FrameAttached && !this.listenerCount(event)) {
+                this.page.on('frameattached', (frame) => {
+                    this.emit(browserLauncher_1.PageEvent.FrameAttached, this.getOrCreateFrame(frame));
+                });
+            }
+            if (event === browserLauncher_1.PageEvent.Console && !this.listenerCount(event)) {
+                this.page.on('console', (console) => {
+                    this.emit(browserLauncher_1.PageEvent.Console, new wrappers_1.PlaywrightWrappedConsoleMessage(console, this));
+                });
+            }
+            if (event === browserLauncher_1.PageEvent.PageError && !this.listenerCount(event)) {
+                this.page.on('pageerror', (error) => {
+                    this.emit(browserLauncher_1.PageEvent.PageError, error);
+                });
+            }
+            if (event === browserLauncher_1.PageEvent.Error && !this.listenerCount(event)) {
+                this.page.on('crash', (error) => {
+                    this.emit(browserLauncher_1.PageEvent.Error, error);
+                });
+            }
+            if (event === browserLauncher_1.PageEvent.TracingBufferUsage &&
+                !this.listenerCount(event)) {
+                this.getCDPSession().on('Tracing.bufferUsage', (tracing) => {
+                    this.emit(browserLauncher_1.PageEvent.TracingBufferUsage, tracing);
+                });
+            }
+            if (event === browserLauncher_1.PageEvent.TracingDataCollected &&
+                !this.listenerCount(event)) {
+                this.getCDPSession().on('Tracing.dataCollected', (data) => {
+                    this.emit(browserLauncher_1.PageEvent.TracingDataCollected, data);
+                });
+            }
+            if (event === browserLauncher_1.PageEvent.TracingComplete && !this.listenerCount(event)) {
+                this.getCDPSession().on('Tracing.tracingComplete', (tracingComplete) => {
+                    this.emit(browserLauncher_1.PageEvent.TracingComplete, tracingComplete);
+                });
+            }
+        }
+        catch (error) {
+            (0, logUtils_1.logInternal)(`Unable to register event ${event.toString()}. Error: ${error}`);
+        }
+    }
+    async screenshot(options) {
+        return this.page.screenshot(options);
+    }
+    sendCharacter(key) {
+        return this.page.keyboard.insertText(key);
+    }
+    getPageId() {
+        return this.pageId;
+    }
+    getPageImpl() {
+        if (this.pageImpl === undefined) {
+            try {
+                return playwright._toImpl(this.page);
+            }
+            catch (e) {
+            }
+        }
+        return this.pageImpl;
+    }
+    viewport() {
+        return this.page.viewportSize() || undefined;
+    }
+    exposeFunction(name, playwrightFunction) {
+        return this.page.exposeFunction(name, playwrightFunction);
+    }
+    close() {
+        return this.page.close();
+    }
+    url() {
+        return this.page.url();
+    }
+    evaluate(pageFunction, arg, secondaryWorld = false) {
+        return this.mainFrame().evaluate(pageFunction, arg, secondaryWorld);
+    }
+    $(selector) {
+        return this.mainFrame().$(selector);
+    }
+    $$(selector) {
+        return this.mainFrame().$$(selector);
+    }
+    async $$eval(selector, pageFunction, arg) {
+        const result = await this.page.$$eval(selector, pageFunction, playwrightDom_1.PlaywrightJsHandle.unwrapProperties(arg));
+        return result;
+    }
+    async $eval(selector, pageFunction, arg) {
+        const result = await this.page.$eval(selector, pageFunction, playwrightDom_1.PlaywrightJsHandle.unwrapProperties(arg));
+        return result;
+    }
+    async $x(xpathQuery) {
+        return (await this.page.$$(`xpath=${xpathQuery}`)).map((element) => new playwrightDom_1.PlaywrightElementHandle(element, this, this.delegate.createElementHandleDelegate(element)));
+    }
+    authenticate(_credentials) {
+        throw new Error('PlaywrightPage.authenticate not implemented');
+    }
+    bringToFront() {
+        return this.page.bringToFront();
+    }
+    cookies() {
+        return this.page.context().cookies(this.page.url());
+    }
+    async deleteCookie(...cookies) {
+        const finalCookies = (await this.cookies()).filter((cookie) => !cookies.find((c) => c.name === cookie.name && c.domain === cookie.domain));
+        await this.page.context().clearCookies();
+        await this.page.context().addCookies(finalCookies);
+    }
+    async evaluateCodeInSecondaryWorld(code, arg) {
+        return (await this.evaluate(code, arg, true));
+    }
+    async evaluateHandleInSecondaryWorld(code, arg) {
+        return new playwrightDom_1.PlaywrightJsHandle(await this.page.evaluateHandle(code, playwrightDom_1.PlaywrightJsHandle.unwrapProperties(arg, true)), this);
+    }
+    frames() {
+        return this.page.frames().map((frame) => this.getOrCreateFrame(frame));
+    }
+    getBrowserBounds() {
+        return this.delegate.getBrowserBounds();
+    }
+    async goto(url, options) {
+        return this.mainFrame().goto(url, options);
+    }
+    isClosed() {
+        return this.page.isClosed();
+    }
+    keyDown(key) {
+        return this.page.keyboard.down(key);
+    }
+    keyUp(key) {
+        return this.page.keyboard.up(key);
+    }
+    mainFrame() {
+        return this.getOrCreateFrame(this.page.mainFrame());
+    }
+    mouseDown() {
+        return this.page.mouse.down();
+    }
+    mouseMove(x, y, options) {
+        return this.page.mouse.move(x, y, options);
+    }
+    mouseUp() {
+        return this.page.mouse.up();
+    }
+    press(key) {
+        return this.page.keyboard.press(key);
+    }
+    async reload(options) {
+        try {
+            return (0, utils_1.mapIfNotNull)(await this.page.reload(options), (response) => new playwrightHttpResponse_1.PlaywrightHttpResponse(this, response));
+        }
+        catch (e) {
+            if (e instanceof playwright.errors.TimeoutError) {
+                throw new browserLauncher_1.RUNNER_ERRORS.TimeoutError(e.message);
+            }
+            throw new browserLauncher_1.RunnerError(e.message);
+        }
+    }
+    async resizeViewport() {
+        await this.delegate.resizeViewport();
+    }
+    async setCookie(...cookies) {
+        const pageUrl = this.url();
+        const startsWithHTTP = pageUrl.startsWith('http');
+        await this.page.context().addCookies(cookies.map((cookie) => {
+            const item = { ...cookie };
+            if (!item.url && !(item.domain || item.path) && startsWithHTTP) {
+                item.url = pageUrl;
+            }
+            return item;
+        }));
+    }
+    async setViewport(viewport) {
+        try {
+            this.browser.maybeSetDefaultViewportSize(viewport);
+            await this.page.setViewportSize(viewport);
+            await this.delegate.setBrowserBounds(viewport.width, viewport.height);
+        }
+        catch (error) {
+            (0, logUtils_1.logInternal)(`Set Browser Bounds during setViewport step failed: ${error}`);
+        }
+    }
+    async emulateDevice(deviceDescriptor) {
+        return this.setViewport({
+            width: deviceDescriptor.width,
+            height: deviceDescriptor.height,
+        });
+    }
+    title() {
+        return this.page.title();
+    }
+    async waitForLoadState(options) {
+        try {
+            await this.page.waitForLoadState(options === null || options === void 0 ? void 0 : options.waitUntil, {
+                timeout: options.timeout,
+            });
+        }
+        catch (e) {
+            if (e instanceof playwright.errors.TimeoutError) {
+                throw new browserLauncher_1.RUNNER_ERRORS.TimeoutError(e.message);
+            }
+            throw new browserLauncher_1.RunnerError(e.message);
+        }
+    }
+    async waitForSelector(selector, options) {
+        return (0, utils_1.mapIfNotNull)(await this.page.waitForSelector(selector, options), (handle) => new playwrightDom_1.PlaywrightElementHandle(handle, this, this.delegate.createElementHandleDelegate(handle)));
+    }
+    async acceptDialogs(dialog) {
+        await dialog.accept();
+    }
+    opener() {
+        return this.openerPage;
+    }
+    setExtraHTTPHeaders(_headers) {
+        throw new Error('PlaywrightPage.setExtraHTTPHeaders not implemented');
+    }
+    makeCDPCall(method, paramArgs) {
+        return this.delegate.makeCDPCall(method, paramArgs);
+    }
+    getCDPSession() {
+        return this.delegate.getCDPSession();
+    }
+    getOrCreateFrame(frame) {
+        const frameId = frame._guid;
+        if (!this.playwrightFrames.has(frameId)) {
+            const newFrame = new playwrightFrame_1.PlaywrightFrame(frame, this, this.delegate.createFrameDelegate(frame));
+            this.playwrightFrames.set(frameId, newFrame);
+        }
+        return this.playwrightFrames.get(frameId);
+    }
+    async getContentAsMhtml() {
+        return this.delegate.getContentAsMhtml();
+    }
+    async download(url, destination, encoding = 'binary') {
+        const response = await this.page.request.fetch(url);
+        const body = await response.body();
+        if (body) {
+            await (0, promises_1.writeFile)(destination, body, { encoding });
+        }
+    }
+}
+exports.PlaywrightPage = PlaywrightPage;

package/browserLauncher/playwrightBrowserLauncher/simplePlaywrightLogger.js

@@ -0,0 +1,36 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SimplePlaywrightLogger = void 0;
+class SimplePlaywrightLogger {
+    constructor(logger, severityAllowList) {
+        this.logger = logger;
+        this.severityAllowList = severityAllowList;
+    }
+    static createWarningLogger(logger) {
+        return new SimplePlaywrightLogger(logger, new Set(['error', 'warning']));
+    }
+    isEnabled(_name, severity) {
+        return this.severityAllowList.has(severity);
+    }
+    log(name, severity, message, args, _hints) {
+        const msg = `[Playwright:${name}:${severity}] ${message} ${args}`;
+        switch (severity) {
+            case 'error':
+                this.logger.error(msg);
+                break;
+            case 'warning':
+                this.logger.warn(msg);
+                break;
+            case 'info':
+                this.logger.info(msg);
+                break;
+            case 'verbose':
+                this.logger.verbose(msg);
+                break;
+            default:
+                this.logger.info(msg);
+                break;
+        }
+    }
+}
+exports.SimplePlaywrightLogger = SimplePlaywrightLogger;

package/browserLauncher/playwrightBrowserLauncher/webkit/webkitBrowserDelegate.js

@@ -0,0 +1,50 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WebkitBrowserDelegate = void 0;
+const playwright = __importStar(require("playwright"));
+const webkitPageDelegate_1 = require("./webkitPageDelegate");
+const nonChromiumAbstractBrowserDelegate_1 = require("../nonChromium/nonChromiumAbstractBrowserDelegate");
+class WebkitBrowserDelegate extends nonChromiumAbstractBrowserDelegate_1.NonChromiumAbstractBrowserDelegate {
+    constructor(context) {
+        super();
+        this.context = context;
+        const contextImpl = playwright._toImpl(context);
+        this._browser = contextImpl._browser;
+    }
+    getBrowser() {
+        return this._browser;
+    }
+    createPageDelegate(page) {
+        return new webkitPageDelegate_1.WebkitPageDelegate(page);
+    }
+    getCDPSession() {
+        return this._browser._connection.browserSession;
+    }
+    supportsExposeFunction() {
+        return false;
+    }
+}
+exports.WebkitBrowserDelegate = WebkitBrowserDelegate;

package/browserLauncher/playwrightBrowserLauncher/webkit/webkitElementHandleDelegate.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WebkitElementHandleDelegate = void 0;
+const nonChromiumAbstractElementHandleDelegate_1 = require("../nonChromium/nonChromiumAbstractElementHandleDelegate");
+class WebkitElementHandleDelegate extends nonChromiumAbstractElementHandleDelegate_1.NonChromiumAbstractElementHandleDelegate {
+    async focusAndSelect(element) {
+        const frame = await element.frame();
+        return frame.evaluate((element) => {
+            var _a;
+            element.focus();
+            (_a = element.select) === null || _a === void 0 ? void 0 : _a.call(element);
+            return element.value;
+        }, element);
+    }
+}
+exports.WebkitElementHandleDelegate = WebkitElementHandleDelegate;

package/browserLauncher/playwrightBrowserLauncher/webkit/webkitFrameDelegate.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WebkitFrameDelegate = void 0;
+const types_1 = require("../../types");
+const nonChromiumAbstractFrameDelegate_1 = require("../nonChromium/nonChromiumAbstractFrameDelegate");
+class WebkitFrameDelegate extends nonChromiumAbstractFrameDelegate_1.NonChromiumAbstractFrameDelegate {
+    addBindingToSecondaryWorld(_binding) {
+        return Promise.resolve();
+    }
+    getLifecycleEventStrategy(value) {
+        let waitUntil = value !== null && value !== void 0 ? value : types_1.LifecycleEvent.Load;
+        const waitForNetworkIdle = waitUntil !== types_1.LifecycleEvent.DomContentLoaded;
+        if (waitForNetworkIdle) {
+            waitUntil = types_1.LifecycleEvent.DomContentLoaded;
+        }
+        return { waitUntil, waitForNetworkIdle };
+    }
+}
+exports.WebkitFrameDelegate = WebkitFrameDelegate;

package/browserLauncher/playwrightBrowserLauncher/webkit/webkitPageDelegate.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WebkitPageDelegate = void 0;
+const webkitElementHandleDelegate_1 = require("./webkitElementHandleDelegate");
+const webkitFrameDelegate_1 = require("./webkitFrameDelegate");
+const nonChromiumAbstractPageDelegate_1 = require("../nonChromium/nonChromiumAbstractPageDelegate");
+class WebkitPageDelegate extends nonChromiumAbstractPageDelegate_1.NonChromiumAbstractPageDelegate {
+    createElementHandleDelegate(element) {
+        return new webkitElementHandleDelegate_1.WebkitElementHandleDelegate(element);
+    }
+    createFrameDelegate(frame) {
+        return new webkitFrameDelegate_1.WebkitFrameDelegate(this, frame);
+    }
+}
+exports.WebkitPageDelegate = WebkitPageDelegate;

package/browserLauncher/playwrightBrowserLauncher/wrappers.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PlaywrightWrappedConsoleMessage = void 0;
+const playwrightDom_1 = require("./playwrightDom");
+class PlaywrightWrappedConsoleMessage {
+    constructor(message, page) {
+        this.message = message;
+        this.page = page;
+    }
+    text() {
+        return this.message.text();
+    }
+    args() {
+        return this.message
+            .args()
+            .map((handle) => new playwrightDom_1.PlaywrightJsHandle(handle, this.page));
+    }
+    type() {
+        return this.message.type();
+    }
+    stackTrace() {
+        return [this.message.location()];
+    }
+}
+exports.PlaywrightWrappedConsoleMessage = PlaywrightWrappedConsoleMessage;

package/browserLauncher/types.js

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WaitForOptions = exports.LifecycleEvent = exports.RunnerType = exports.DefaultApiRequestSettings = exports.DefaultTimeouts = void 0;
+class DefaultTimeouts {
+}
+exports.DefaultTimeouts = DefaultTimeouts;
+DefaultTimeouts.defaultTrialTimeoutMs = 5000;
+DefaultTimeouts.defaultWaitTimeoutMs = 5000;
+DefaultTimeouts.defaultActionTimeoutMs = 0;
+class DefaultApiRequestSettings {
+}
+exports.DefaultApiRequestSettings = DefaultApiRequestSettings;
+DefaultApiRequestSettings.defaultApiRequestTimeout = 2 * 60 * 1000;
+DefaultApiRequestSettings.defaultMaxRedirects = 5;
+DefaultApiRequestSettings.verifyUrlBatchSize = 20;
+var RunnerType;
+(function (RunnerType) {
+    RunnerType["Playwright"] = "playwright";
+})(RunnerType || (exports.RunnerType = RunnerType = {}));
+var LifecycleEvent;
+(function (LifecycleEvent) {
+    LifecycleEvent["DomContentLoaded"] = "domcontentloaded";
+    LifecycleEvent["Load"] = "load";
+    LifecycleEvent["NetworkIdle"] = "networkidle";
+})(LifecycleEvent || (exports.LifecycleEvent = LifecycleEvent = {}));
+class WaitForOptions {
+}
+exports.WaitForOptions = WaitForOptions;

package/browserLauncher/utils.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.mapIfNotNull = void 0;
+function mapIfNotNull(value, callIfNotNull) {
+    return value === null || value === undefined
+        ? undefined
+        : callIfNotNull(value);
+}
+exports.mapIfNotNull = mapIfNotNull;

package/cli.js

@@ -0,0 +1,66 @@
+#!/usr/bin/env node
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const yargs = __importStar(require("yargs"));
+const env_1 = require("./env/env");
+const constants_1 = require("./commands/constants");
+const middleware_1 = require("./middleware");
+const path_1 = __importDefault(require("path"));
+const fs_1 = __importDefault(require("fs"));
+require('yargonaut').style('cyan').helpStyle('magenta').errorsStyle('red');
+const hasInternalDirectory = fs_1.default.existsSync(path_1.default.resolve(__dirname, 'commands', 'internal', 'internal_cmds'));
+const excludeInternal = !hasInternalDirectory ? { exclude: /.*/gm } : undefined;
+yargs
+    .scriptName(env_1.SCRIPT_NAME)
+    .commandDir('./commands/applications')
+    .commandDir('./commands/auth')
+    .commandDir('./commands/branches')
+    .commandDir('./commands/config')
+    .commandDir('./commands/credentials')
+    .commandDir('./commands/datatables')
+    .commandDir('./commands/deploy')
+    .commandDir('./commands/environments')
+    .commandDir('./commands/flows')
+    .commandDir('./commands/internal', excludeInternal)
+    .commandDir('./commands/link-agents')
+    .commandDir('./commands/mobile-build-files')
+    .commandDir('./commands/plans')
+    .commandDir('./commands/tests')
+    .commandDir('./commands/test-runs')
+    .commandDir('./commands/users')
+    .commandDir('./commands/workspaces')
+    .demandCommand(1, '')
+    .recommendCommands()
+    .strict()
+    .help(constants_1.CommandArgHelp)
+    .alias(constants_1.CommandArgHelp, constants_1.CommandArgAliases.ShowHelp)
+    .alias(constants_1.CommandArgVersion, constants_1.CommandArgAliases.Version)
+    .wrap(null)
+    .epilogue('Read full docs @ https://help.mabl.com/docs/mabl-cli')
+    .middleware(middleware_1.CLI_MIDDLEWARE).argv;

package/commands/applications/applications.js

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.command = 'applications <command>';
+exports.describe = 'Manage your applications';
+exports.builder = (yargs) => yargs.commandDir('applications_cmds').demandCommand();

package/commands/applications/applications_cmds/describe.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const mablApiClientFactory_1 = require("../../../api/mablApiClientFactory");
+const describe_1 = require("../../commandUtil/describe");
+const util_1 = require("../../commandUtil/util");
+exports.command = 'describe <id>';
+exports.describe = (0, util_1.getDescribeDescriptions)('application');
+exports.builder = (0, describe_1.getDescribeBuilderOptions)();
+exports.handler = (0, util_1.failWrapper)(getApplication);
+async function getApplication(parsed) {
+    try {
+        const applicationId = parsed.id;
+        const apiClient = await mablApiClientFactory_1.MablApiClientFactory.createApiClient();
+        const application = await apiClient.getApplication(applicationId);
+        (0, describe_1.outputEntity)(application, parsed.output);
+        return application.id;
+    }
+    catch (error) {
+        throw new Error(`Error getting application: ${error}`);
+    }
+}