chrome-devtools-mcp 0.10.1 → 0.11.0

package/build/src/DevtoolsUtils.js

@@ -3,6 +3,11 @@
  * Copyright 2025 Google LLC
  * SPDX-License-Identifier: Apache-2.0
  */
+import { DebuggerModel, Foundation, TargetManager, MarkdownIssueDescription, Marked, ProtocolClient, Common, I18n, } from '../node_modules/chrome-devtools-frontend/mcp/mcp.js';
+import { PuppeteerDevToolsConnection } from './DevToolsConnectionAdapter.js';
+import { ISSUE_UTILS } from './issue-descriptions.js';
+import { logger } from './logger.js';
+import { Mutex } from './Mutex.js';
 export function extractUrlLikeFromDevToolsTitle(title) {
     const match = title.match(new RegExp(`DevTools - (.*)`));
     return match?.[1] ?? undefined;
@@ -19,6 +24,7 @@ export function urlsEqual(url1, url2) {
  * 1. We do not care about the protocol.
  * 2. We do not care about trailing slashes.
  * 3. We do not care about "www".
+ * 4. We ignore the hash parts.
  *
  * For example, if the user types "record a trace on foo.com", we would want to
  * match a tab in the connected Chrome instance that is showing "www.foo.com/"
@@ -36,9 +42,165 @@ function normalizeUrl(url) {
     if (result.startsWith('www.')) {
         result = result.slice(4);
     }
+    // We use target URLs to locate DevTools but those often do
+    // no include hash.
+    const hashIdx = result.lastIndexOf('#');
+    if (hashIdx !== -1) {
+        result = result.slice(0, hashIdx);
+    }
     // Remove trailing slash
     if (result.endsWith('/')) {
         result = result.slice(0, -1);
     }
     return result;
 }
+/**
+ * A mock implementation of an issues manager that only implements the methods
+ * that are actually used by the IssuesAggregator
+ */
+export class FakeIssuesManager extends Common.ObjectWrapper
+    .ObjectWrapper {
+    issues() {
+        return [];
+    }
+}
+export function mapIssueToMessageObject(issue) {
+    const count = issue.getAggregatedIssuesCount();
+    const markdownDescription = issue.getDescription();
+    const filename = markdownDescription?.file;
+    if (!markdownDescription) {
+        logger(`no description found for issue:` + issue.code);
+        return null;
+    }
+    const rawMarkdown = filename
+        ? ISSUE_UTILS.getIssueDescription(filename)
+        : null;
+    if (!rawMarkdown) {
+        logger(`no markdown ${filename} found for issue:` + issue.code);
+        return null;
+    }
+    let processedMarkdown;
+    let title;
+    try {
+        processedMarkdown = MarkdownIssueDescription.substitutePlaceholders(rawMarkdown, markdownDescription.substitutions);
+        const markdownAst = Marked.Marked.lexer(processedMarkdown);
+        title = MarkdownIssueDescription.findTitleFromMarkdownAst(markdownAst);
+    }
+    catch {
+        logger('error parsing markdown for issue ' + issue.code());
+        return null;
+    }
+    if (!title) {
+        logger('cannot read issue title from ' + filename);
+        return null;
+    }
+    return {
+        type: 'issue',
+        item: issue,
+        message: title,
+        count,
+        description: processedMarkdown,
+    };
+}
+// DevTools CDP errors can get noisy.
+ProtocolClient.InspectorBackend.test.suppressRequestErrors = true;
+I18n.DevToolsLocale.DevToolsLocale.instance({
+    create: true,
+    data: {
+        navigatorLanguage: 'en-US',
+        settingLanguage: 'en-US',
+        lookupClosestDevToolsLocale: l => l,
+    },
+});
+I18n.i18n.registerLocaleDataForTest('en-US', {});
+export class UniverseManager {
+    #browser;
+    #createUniverseFor;
+    #universes = new WeakMap();
+    /** Guard access to #universes so we don't create unnecessary universes */
+    #mutex = new Mutex();
+    constructor(browser, factory = DEFAULT_FACTORY) {
+        this.#browser = browser;
+        this.#createUniverseFor = factory;
+    }
+    async init(pages) {
+        try {
+            await this.#mutex.acquire();
+            const promises = [];
+            for (const page of pages) {
+                promises.push(this.#createUniverseFor(page).then(targetUniverse => this.#universes.set(page, targetUniverse)));
+            }
+            this.#browser.on('targetcreated', this.#onTargetCreated);
+            this.#browser.on('targetdestroyed', this.#onTargetDestroyed);
+            await Promise.all(promises);
+        }
+        finally {
+            this.#mutex.release();
+        }
+    }
+    get(page) {
+        return this.#universes.get(page) ?? null;
+    }
+    dispose() {
+        this.#browser.off('targetcreated', this.#onTargetCreated);
+        this.#browser.off('targetdestroyed', this.#onTargetDestroyed);
+    }
+    #onTargetCreated = async (target) => {
+        const page = await target.page();
+        try {
+            await this.#mutex.acquire();
+            if (!page || this.#universes.has(page)) {
+                return;
+            }
+            this.#universes.set(page, await this.#createUniverseFor(page));
+        }
+        finally {
+            this.#mutex.release();
+        }
+    };
+    #onTargetDestroyed = async (target) => {
+        const page = await target.page();
+        try {
+            await this.#mutex.acquire();
+            if (!page || !this.#universes.has(page)) {
+                return;
+            }
+            this.#universes.delete(page);
+        }
+        finally {
+            this.#mutex.release();
+        }
+    };
+}
+const DEFAULT_FACTORY = async (page) => {
+    const settingStorage = new Common.Settings.SettingsStorage({});
+    const universe = new Foundation.Universe.Universe({
+        settingsCreationOptions: {
+            syncedStorage: settingStorage,
+            globalStorage: settingStorage,
+            localStorage: settingStorage,
+            settingRegistrations: Common.SettingRegistration.getRegisteredSettings(),
+        },
+        overrideAutoStartModels: new Set([DebuggerModel]),
+    });
+    const session = await page.createCDPSession();
+    const connection = new PuppeteerDevToolsConnection(session);
+    const targetManager = universe.context.get(TargetManager);
+    targetManager.observeModels(DebuggerModel, SKIP_ALL_PAUSES);
+    const target = targetManager.createTarget('main', '', 'frame', // eslint-disable-line @typescript-eslint/no-explicit-any
+    /* parentTarget */ null, session.id(), undefined, connection);
+    return { target, universe };
+};
+// We don't want to pause any DevTools universe session ever on the MCP side.
+//
+// Note that calling `setSkipAllPauses` only affects the session on which it was
+// sent. This means DevTools can still pause, step and do whatever. We just won't
+// see the `Debugger.paused`/`Debugger.resumed` events on the MCP side.
+const SKIP_ALL_PAUSES = {
+    modelAdded(model) {
+        void model.agent.invoke_setSkipAllPauses({ skip: true });
+    },
+    modelRemoved() {
+        // Do nothing.
+    },
+};

package/build/src/McpContext.js

@@ -7,7 +7,7 @@ import fs from 'node:fs/promises';
 import os from 'node:os';
 import path from 'node:path';
 import { extractUrlLikeFromDevToolsTitle, urlsEqual } from './DevtoolsUtils.js';
-import { NetworkCollector, PageCollector } from './PageCollector.js';
+import { NetworkCollector, ConsoleCollector } from './PageCollector.js';
 import { Locator } from './third_party/index.js';
 import { listPages } from './tools/pages.js';
 import { takeSnapshot } from './tools/snapshot.js';
@@ -54,6 +54,7 @@ export class McpContext {
     #isRunningTrace = false;
     #networkConditionsMap = new WeakMap();
     #cpuThrottlingRateMap = new WeakMap();
+    #geolocationMap = new WeakMap();
     #dialog;
     #nextSnapshotId = 1;
     #traceResults = [];
@@ -64,8 +65,8 @@ export class McpContext {
         this.logger = logger;
         this.#locatorClass = locatorClass;
         this.#options = options;
-        this.#networkCollector = new NetworkCollector(this.browser, undefined, this.#options.experimentalIncludeAllPages);
-        this.#consoleCollector = new PageCollector(this.browser, collect => {
+        this.#networkCollector = new NetworkCollector(this.browser);
+        this.#consoleCollector = new ConsoleCollector(this.browser, collect => {
             return {
                 console: event => {
                     collect(event);
@@ -80,13 +81,20 @@ export class McpContext {
                         collect(error);
                     }
                 },
+                issue: event => {
+                    collect(event);
+                },
             };
-        }, this.#options.experimentalIncludeAllPages);
+        });
     }
     async #init() {
-        await this.createPagesSnapshot();
-        await this.#networkCollector.init();
-        await this.#consoleCollector.init();
+        const pages = await this.createPagesSnapshot();
+        await this.#networkCollector.init(pages);
+        await this.#consoleCollector.init(pages);
+    }
+    dispose() {
+        this.#networkCollector.dispose();
+        this.#consoleCollector.dispose();
     }
     static async from(browser, logger, opts, 
     /* Let tests use unbundled Locator class to avoid overly strict checks within puppeteer that fail when mixing bundled and unbundled class instances */
@@ -116,8 +124,12 @@ export class McpContext {
             this.logger('no cdpBackendNodeId');
             return;
         }
+        if (this.#textSnapshot === null) {
+            this.logger('no text snapshot');
+            return;
+        }
         // TODO: index by backendNodeId instead.
-        const queue = [this.#textSnapshot?.root];
+        const queue = [this.#textSnapshot.root];
         while (queue.length) {
             const current = queue.pop();
             if (current.backendNodeId === cdpBackendNodeId) {
@@ -184,6 +196,19 @@ export class McpContext {
         const page = this.getSelectedPage();
         return this.#cpuThrottlingRateMap.get(page) ?? 1;
     }
+    setGeolocation(geolocation) {
+        const page = this.getSelectedPage();
+        if (geolocation === null) {
+            this.#geolocationMap.delete(page);
+        }
+        else {
+            this.#geolocationMap.set(page, geolocation);
+        }
+    }
+    getGeolocation() {
+        const page = this.getSelectedPage();
+        return this.#geolocationMap.get(page) ?? null;
+    }
     setIsRunningPerformanceTrace(x) {
         this.#isRunningTrace = x;
     }
@@ -277,7 +302,8 @@ export class McpContext {
             return (this.#options.experimentalDevToolsDebugging ||
                 !page.url().startsWith('devtools://'));
         });
-        if (!this.#selectedPage || this.#pages.indexOf(this.#selectedPage) === -1) {
+        if ((!this.#selectedPage || this.#pages.indexOf(this.#selectedPage) === -1) &&
+            this.#pages[0]) {
             this.selectPage(this.#pages[0]);
         }
         await this.detectOpenDevToolsWindows();
@@ -388,9 +414,12 @@ export class McpContext {
             root: rootNodeWithId,
             snapshotId: String(snapshotId),
             idToNode,
+            hasSelectedElement: false,
+            verbose,
         };
         const data = devtoolsData ?? (await this.getDevToolsData());
         if (data?.cdpBackendNodeId) {
+            this.#textSnapshot.hasSelectedElement = true;
             this.#textSnapshot.selectedElementUid = this.resolveCdpElementId(data?.cdpBackendNodeId);
         }
     }
@@ -439,15 +468,15 @@ export class McpContext {
     getNetworkRequestStableId(request) {
         return this.#networkCollector.getIdForResource(request);
     }
-    waitForTextOnPage({ text, timeout, }) {
+    waitForTextOnPage(text, timeout) {
         const page = this.getSelectedPage();
         const frames = page.frames();
-        const locator = this.#locatorClass.race(frames.flatMap(frame => [
+        let locator = this.#locatorClass.race(frames.flatMap(frame => [
             frame.locator(`aria/${text}`),
             frame.locator(`text/${text}`),
         ]));
         if (timeout) {
-            locator.setTimeout(timeout);
+            locator = locator.setTimeout(timeout);
         }
         return locator.wait();
     }
@@ -465,6 +494,6 @@ export class McpContext {
                 },
             };
         });
-        await this.#networkCollector.init();
+        await this.#networkCollector.init(await this.browser.pages());
     }
 }

package/build/src/McpResponse.js

@@ -1,3 +1,10 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { AggregatedIssue } from '../node_modules/chrome-devtools-frontend/mcp/mcp.js';
+import { mapIssueToMessageObject } from './DevtoolsUtils.js';
 import { formatConsoleEventShort, formatConsoleEventVerbose, } from './formatters/consoleFormatter.js';
 import { getFormattedHeaderValue, getFormattedResponseBody, getFormattedRequestBody, getShortDescriptionForRequest, getStatusFromRequest, } from './formatters/networkFormatter.js';
 import { formatSnapshotNode } from './formatters/snapshotFormatter.js';
@@ -148,6 +155,15 @@ export class McpResponse {
                     })),
                 };
             }
+            else if (message instanceof AggregatedIssue) {
+                const mappedIssueMessage = mapIssueToMessageObject(message);
+                if (!mappedIssueMessage)
+                    throw new Error("Can't provide detals for the msgid " + consoleMessageStableId);
+                consoleData = {
+                    consoleMessageStableId,
+                    ...mappedIssueMessage,
+                };
+            }
             else {
                 consoleData = {
                     consoleMessageStableId,
@@ -166,10 +182,13 @@ export class McpResponse {
                     if ('type' in message) {
                         return normalizedTypes.has(message.type());
                     }
+                    if (message instanceof AggregatedIssue) {
+                        return normalizedTypes.has('issue');
+                    }
                     return normalizedTypes.has('error');
                 });
             }
-            consoleListData = await Promise.all(messages.map(async (item) => {
+            consoleListData = (await Promise.all(messages.map(async (item) => {
                 const consoleMessageStableId = context.getConsoleMessageStableId(item);
                 if ('args' in item) {
                     const consoleMessage = item;
@@ -187,13 +206,22 @@ export class McpResponse {
                         })),
                     };
                 }
+                if (item instanceof AggregatedIssue) {
+                    const mappedIssueMessage = mapIssueToMessageObject(item);
+                    if (!mappedIssueMessage)
+                        return null;
+                    return {
+                        consoleMessageStableId,
+                        ...mappedIssueMessage,
+                    };
+                }
                 return {
                     consoleMessageStableId,
                     type: 'error',
                     message: item.message,
                     args: [],
                 };
-            }));
+            }))).filter(item => item !== null);
         }
         return this.format(toolName, context, {
             bodies,
@@ -237,11 +265,11 @@ Call ${handleDialog.name} to handle it before continuing.`);
             response.push(...parts);
         }
         if (data.formattedSnapshot) {
-            response.push('## Page content');
+            response.push('## Latest page snapshot');
             response.push(data.formattedSnapshot);
         }
         response.push(...this.#formatNetworkRequestData(context, data.bodies));
-        response.push(...this.#formatConsoleData(data.consoleData));
+        response.push(...this.#formatConsoleData(context, data.consoleData));
         if (this.#networkRequestsOptions?.include) {
             let requests = context.getNetworkRequests(this.#networkRequestsOptions?.includePreservedRequests);
             // Apply resource type filtering if specified
@@ -310,12 +338,12 @@ Call ${handleDialog.name} to handle it before continuing.`);
             items: paginationResult.items,
         };
     }
-    #formatConsoleData(data) {
+    #formatConsoleData(context, data) {
         const response = [];
         if (!data) {
             return response;
         }
-        response.push(formatConsoleEventVerbose(data));
+        response.push(formatConsoleEventVerbose(data, context));
         return response;
     }
     #formatNetworkRequestData(context, data) {

package/build/src/PageCollector.js

@@ -3,6 +3,9 @@
  * Copyright 2025 Google LLC
  * SPDX-License-Identifier: Apache-2.0
  */
+import { createIssuesFromProtocolIssue, IssueAggregator, } from '../node_modules/chrome-devtools-frontend/mcp/mcp.js';
+import { FakeIssuesManager } from './DevtoolsUtils.js';
+import { logger } from './logger.js';
 function createIdGenerator() {
     let i = 1;
     return () => {
@@ -18,38 +21,41 @@ export class PageCollector {
     #listenersInitializer;
     #listeners = new WeakMap();
     #maxNavigationSaved = 3;
-    #includeAllPages;
     /**
      * This maps a Page to a list of navigations with a sub-list
      * of all collected resources.
      * The newer navigations come first.
      */
     storage = new WeakMap();
-    constructor(browser, listeners, includeAllPages) {
+    constructor(browser, listeners) {
         this.#browser = browser;
         this.#listenersInitializer = listeners;
-        this.#includeAllPages = includeAllPages;
     }
-    async init() {
-        const pages = await this.#browser.pages(this.#includeAllPages);
+    async init(pages) {
         for (const page of pages) {
-            this.#initializePage(page);
+            this.addPage(page);
         }
-        this.#browser.on('targetcreated', async (target) => {
-            const page = await target.page();
-            if (!page) {
-                return;
-            }
-            this.#initializePage(page);
-        });
-        this.#browser.on('targetdestroyed', async (target) => {
-            const page = await target.page();
-            if (!page) {
-                return;
-            }
-            this.#cleanupPageDestroyed(page);
-        });
+        this.#browser.on('targetcreated', this.#onTargetCreated);
+        this.#browser.on('targetdestroyed', this.#onTargetDestroyed);
     }
+    dispose() {
+        this.#browser.off('targetcreated', this.#onTargetCreated);
+        this.#browser.off('targetdestroyed', this.#onTargetDestroyed);
+    }
+    #onTargetCreated = async (target) => {
+        const page = await target.page();
+        if (!page) {
+            return;
+        }
+        this.addPage(page);
+    };
+    #onTargetDestroyed = async (target) => {
+        const page = await target.page();
+        if (!page) {
+            return;
+        }
+        this.cleanupPageDestroyed(page);
+    };
     addPage(page) {
         this.#initializePage(page);
     }
@@ -87,7 +93,7 @@ export class PageCollector {
         navigations.unshift([]);
         navigations.splice(this.#maxNavigationSaved);
     }
-    #cleanupPageDestroyed(page) {
+    cleanupPageDestroyed(page) {
         const listeners = this.#listeners.get(page);
         if (listeners) {
             for (const [name, listener] of Object.entries(listeners)) {
@@ -140,6 +146,108 @@ export class PageCollector {
         return;
     }
 }
+export class ConsoleCollector extends PageCollector {
+    #subscribedPages = new WeakMap();
+    addPage(page) {
+        super.addPage(page);
+        if (!this.#subscribedPages.has(page)) {
+            const subscriber = new PageIssueSubscriber(page);
+            this.#subscribedPages.set(page, subscriber);
+            void subscriber.subscribe();
+        }
+    }
+    cleanupPageDestroyed(page) {
+        super.cleanupPageDestroyed(page);
+        this.#subscribedPages.get(page)?.unsubscribe();
+        this.#subscribedPages.delete(page);
+    }
+}
+class PageIssueSubscriber {
+    #issueManager = new FakeIssuesManager();
+    #issueAggregator = new IssueAggregator(this.#issueManager);
+    #seenKeys = new Set();
+    #seenIssues = new Set();
+    #page;
+    #session;
+    constructor(page) {
+        this.#page = page;
+        // @ts-expect-error use existing CDP client (internal Puppeteer API).
+        this.#session = this.#page._client();
+    }
+    #resetIssueAggregator() {
+        this.#issueManager = new FakeIssuesManager();
+        if (this.#issueAggregator) {
+            this.#issueAggregator.removeEventListener("AggregatedIssueUpdated" /* IssueAggregatorEvents.AGGREGATED_ISSUE_UPDATED */, this.#onAggregatedissue);
+        }
+        this.#issueAggregator = new IssueAggregator(this.#issueManager);
+        this.#issueAggregator.addEventListener("AggregatedIssueUpdated" /* IssueAggregatorEvents.AGGREGATED_ISSUE_UPDATED */, this.#onAggregatedissue);
+    }
+    async subscribe() {
+        this.#resetIssueAggregator();
+        this.#page.on('framenavigated', this.#onFrameNavigated);
+        this.#session.on('Audits.issueAdded', this.#onIssueAdded);
+        try {
+            await this.#session.send('Audits.enable');
+        }
+        catch (error) {
+            logger('Error subscribing to issues', error);
+        }
+    }
+    unsubscribe() {
+        this.#seenKeys.clear();
+        this.#seenIssues.clear();
+        this.#page.off('framenavigated', this.#onFrameNavigated);
+        this.#session.off('Audits.issueAdded', this.#onIssueAdded);
+        if (this.#issueAggregator) {
+            this.#issueAggregator.removeEventListener("AggregatedIssueUpdated" /* IssueAggregatorEvents.AGGREGATED_ISSUE_UPDATED */, this.#onAggregatedissue);
+        }
+        void this.#session.send('Audits.disable').catch(() => {
+            // might fail.
+        });
+    }
+    #onAggregatedissue = (event) => {
+        if (this.#seenIssues.has(event.data)) {
+            return;
+        }
+        this.#seenIssues.add(event.data);
+        this.#page.emit('issue', event.data);
+    };
+    // On navigation, we reset issue aggregation.
+    #onFrameNavigated = (frame) => {
+        // Only split the storage on main frame navigation
+        if (frame !== frame.page().mainFrame()) {
+            return;
+        }
+        this.#seenKeys.clear();
+        this.#seenIssues.clear();
+        this.#resetIssueAggregator();
+    };
+    #onIssueAdded = (data) => {
+        try {
+            const inspectorIssue = data.issue;
+            // @ts-expect-error Types of protocol from Puppeteer and CDP are
+            // incomparable for InspectorIssueCode, one is union, other is enum.
+            const issue = createIssuesFromProtocolIssue(null, inspectorIssue)[0];
+            if (!issue) {
+                logger('No issue mapping for for the issue: ', inspectorIssue.code);
+                return;
+            }
+            const primaryKey = issue.primaryKey();
+            if (this.#seenKeys.has(primaryKey)) {
+                return;
+            }
+            this.#seenKeys.add(primaryKey);
+            this.#issueManager.dispatchEventToListeners("IssueAdded" /* IssuesManagerEvents.ISSUE_ADDED */, {
+                issue,
+                // @ts-expect-error We don't care that issues model is null
+                issuesModel: null,
+            });
+        }
+        catch (error) {
+            logger('Error creating a new issue', error);
+        }
+    };
+}
 export class NetworkCollector extends PageCollector {
     constructor(browser, listeners = collect => {
         return {
@@ -147,8 +255,8 @@ export class NetworkCollector extends PageCollector {
                 collect(req);
             },
         };
-    }, includeAllPages) {
-        super(browser, listeners, includeAllPages);
+    }) {
+        super(browser, listeners);
     }
     splitAfterNavigation(page) {
         const navigations = this.storage.get(page) ?? [];

package/build/src/browser.js

@@ -19,6 +19,10 @@ function makeTargetFilter() {
         if (target.url() === 'chrome://newtab/') {
             return true;
         }
+        // Could be the only page opened in the browser.
+        if (target.url().startsWith('chrome://inspect')) {
+            return true;
+        }
         for (const prefix of ignoredPrefixes) {
             if (target.url().startsWith(prefix)) {
                 return false;

package/build/src/cli.js

@@ -7,7 +7,7 @@ import { yargs, hideBin } from './third_party/index.js';
 export const cliOptions = {
     browserUrl: {
         type: 'string',
-        description: 'Connect to a running Chrome instance using port forwarding. For more details see: https://developer.chrome.com/docs/devtools/remote-debugging/local-server.',
+        description: 'Connect to a running, debuggable Chrome instance (e.g. `http://127.0.0.1:9222`). For more details see: https://github.com/ChromeDevTools/chrome-devtools-mcp#connecting-to-a-running-chrome-instance.',
         alias: 'u',
         conflicts: 'wsEndpoint',
         coerce: (url) => {
@@ -80,8 +80,12 @@ export const cliOptions = {
     },
     isolated: {
         type: 'boolean',
-        description: 'If specified, creates a temporary user-data-dir that is automatically cleaned up after the browser is closed.',
-        default: false,
+        description: 'If specified, creates a temporary user-data-dir that is automatically cleaned up after the browser is closed. Defaults to false.',
+    },
+    userDataDir: {
+        type: 'string',
+        description: 'Path to the user data directory for Chrome. Default is $HOME/.cache/chrome-devtools-mcp/chrome-profile$CHANNEL_SUFFIX_IF_NON_STABLE',
+        conflicts: ['browserUrl', 'wsEndpoint', 'isolated'],
     },
     channel: {
         type: 'string',
@@ -196,6 +200,10 @@ export function parseArguments(version, argv = process.argv) {
             'Disable tools in the performance category',
         ],
         ['$0 --no-category-network', 'Disable tools in the network category'],
+        [
+            '$0 --user-data-dir=/tmp/user-data-dir',
+            'Use a custom user data directory',
+        ],
     ]);
     return yargsInstance
         .wrap(Math.min(120, yargsInstance.terminalWidth()))