@playwright/mcp 0.0.31 → 0.0.33

package/lib/context.js

@@ -14,58 +14,46 @@
  * limitations under the License.
  */
 import debug from 'debug';
-import { callOnPageNoTrace, waitForCompletion } from './tools/utils.js';
-import { ManualPromise } from './manualPromise.js';
+import { logUnhandledError } from './log.js';
 import { Tab } from './tab.js';
 import { outputFile } from './config.js';
 const testDebug = debug('pw:mcp:test');
 export class Context {
     tools;
     config;
+    sessionLog;
+    options;
     _browserContextPromise;
     _browserContextFactory;
     _tabs = [];
     _currentTab;
-    _modalStates = [];
-    _pendingAction;
-    _downloads = [];
-    clientVersion;
-    constructor(tools, config, browserContextFactory) {
-        this.tools = tools;
-        this.config = config;
-        this._browserContextFactory = browserContextFactory;
+    _clientInfo;
+    static _allContexts = new Set();
+    _closeBrowserContextPromise;
+    _isRunningTool = false;
+    _abortController = new AbortController();
+    constructor(options) {
+        this.tools = options.tools;
+        this.config = options.config;
+        this.sessionLog = options.sessionLog;
+        this.options = options;
+        this._browserContextFactory = options.browserContextFactory;
+        this._clientInfo = options.clientInfo;
         testDebug('create context');
+        Context._allContexts.add(this);
     }
-    clientSupportsImages() {
-        if (this.config.imageResponses === 'omit')
-            return false;
-        return true;
-    }
-    modalStates() {
-        return this._modalStates;
-    }
-    setModalState(modalState, inTab) {
-        this._modalStates.push({ ...modalState, tab: inTab });
-    }
-    clearModalState(modalState) {
-        this._modalStates = this._modalStates.filter(state => state !== modalState);
-    }
-    modalStatesMarkdown() {
-        const result = ['### Modal state'];
-        if (this._modalStates.length === 0)
-            result.push('- There is no modal state present');
-        for (const state of this._modalStates) {
-            const tool = this.tools.find(tool => tool.clearsModalState === state.type);
-            result.push(`- [${state.description}]: can be handled by the "${tool?.schema.name}" tool`);
-        }
-        return result;
+    static async disposeAll() {
+        await Promise.all([...Context._allContexts].map(context => context.dispose()));
     }
     tabs() {
         return this._tabs;
     }
+    currentTab() {
+        return this._currentTab;
+    }
     currentTabOrDie() {
         if (!this._currentTab)
-            throw new Error('No current snapshot available. Capture a snapshot or navigate to a new location first.');
+            throw new Error('No open pages available. Use the "browser_navigate" tool to navigate to a page first.');
         return this._currentTab;
     }
     async newTab() {
@@ -75,8 +63,12 @@ export class Context {
         return this._currentTab;
     }
     async selectTab(index) {
-        this._currentTab = this._tabs[index];
-        await this._currentTab.page.bringToFront();
+        const tab = this._tabs[index];
+        if (!tab)
+            throw new Error(`Tab ${index} not found`);
+        await tab.page.bringToFront();
+        this._currentTab = tab;
+        return tab;
     }
     async ensureTab() {
         const { browserContext } = await this._ensureBrowserContext();
@@ -84,147 +76,16 @@ export class Context {
             await browserContext.newPage();
         return this._currentTab;
     }
-    async listTabsMarkdown() {
-        if (!this._tabs.length)
-            return '### No tabs open';
-        const lines = ['### Open tabs'];
-        for (let i = 0; i < this._tabs.length; i++) {
-            const tab = this._tabs[i];
-            const title = await tab.title();
-            const url = tab.page.url();
-            const current = tab === this._currentTab ? ' (current)' : '';
-            lines.push(`- ${i}:${current} [${title}] (${url})`);
-        }
-        return lines.join('\n');
-    }
     async closeTab(index) {
         const tab = index === undefined ? this._currentTab : this._tabs[index];
-        await tab?.page.close();
-        return await this.listTabsMarkdown();
-    }
-    async run(tool, params) {
-        // Tab management is done outside of the action() call.
-        const toolResult = await tool.handle(this, tool.schema.inputSchema.parse(params || {}));
-        const { code, action, waitForNetwork, captureSnapshot, resultOverride } = toolResult;
-        if (resultOverride)
-            return resultOverride;
-        if (!this._currentTab) {
-            return {
-                content: [{
-                        type: 'text',
-                        text: 'No open pages available. Use the "browser_navigate" tool to navigate to a page first.',
-                    }],
-            };
-        }
-        const tab = this.currentTabOrDie();
-        // TODO: race against modal dialogs to resolve clicks.
-        const actionResult = await this._raceAgainstModalDialogs(async () => {
-            try {
-                if (waitForNetwork)
-                    return await waitForCompletion(this, tab, async () => action?.()) ?? undefined;
-                else
-                    return await action?.() ?? undefined;
-            }
-            finally {
-                if (captureSnapshot && !this._javaScriptBlocked())
-                    await tab.captureSnapshot();
-            }
-        });
-        const result = [];
-        result.push(`### Ran Playwright code
-\`\`\`js
-${code.join('\n')}
-\`\`\``);
-        if (this.modalStates().length) {
-            result.push('', ...this.modalStatesMarkdown());
-            return {
-                content: [{
-                        type: 'text',
-                        text: result.join('\n'),
-                    }],
-            };
-        }
-        const messages = tab.takeRecentConsoleMessages();
-        if (messages.length) {
-            result.push('', `### New console messages`);
-            for (const message of messages)
-                result.push(`- ${trim(message.toString(), 100)}`);
-        }
-        if (this._downloads.length) {
-            result.push('', '### Downloads');
-            for (const entry of this._downloads) {
-                if (entry.finished)
-                    result.push(`- Downloaded file ${entry.download.suggestedFilename()} to ${entry.outputFile}`);
-                else
-                    result.push(`- Downloading file ${entry.download.suggestedFilename()} ...`);
-            }
-        }
-        if (captureSnapshot && tab.hasSnapshot()) {
-            if (this.tabs().length > 1)
-                result.push('', await this.listTabsMarkdown());
-            if (this.tabs().length > 1)
-                result.push('', '### Current tab');
-            else
-                result.push('', '### Page state');
-            result.push(`- Page URL: ${tab.page.url()}`, `- Page Title: ${await tab.title()}`);
-            result.push(tab.snapshotOrDie().text());
-        }
-        const content = actionResult?.content ?? [];
-        return {
-            content: [
-                ...content,
-                {
-                    type: 'text',
-                    text: result.join('\n'),
-                }
-            ],
-        };
-    }
-    async waitForTimeout(time) {
-        if (!this._currentTab || this._javaScriptBlocked()) {
-            await new Promise(f => setTimeout(f, time));
-            return;
-        }
-        await callOnPageNoTrace(this._currentTab.page, page => {
-            return page.evaluate(() => new Promise(f => setTimeout(f, 1000)));
-        });
-    }
-    async _raceAgainstModalDialogs(action) {
-        this._pendingAction = {
-            dialogShown: new ManualPromise(),
-        };
-        let result;
-        try {
-            await Promise.race([
-                action().then(r => result = r),
-                this._pendingAction.dialogShown,
-            ]);
-        }
-        finally {
-            this._pendingAction = undefined;
-        }
-        return result;
+        if (!tab)
+            throw new Error(`Tab ${index} not found`);
+        const url = tab.page.url();
+        await tab.page.close();
+        return url;
     }
-    _javaScriptBlocked() {
-        return this._modalStates.some(state => state.type === 'dialog');
-    }
-    dialogShown(tab, dialog) {
-        this.setModalState({
-            type: 'dialog',
-            description: `"${dialog.type()}" dialog with message "${dialog.message()}"`,
-            dialog,
-        }, tab);
-        this._pendingAction?.dialogShown.resolve();
-    }
-    async downloadStarted(tab, download) {
-        const entry = {
-            download,
-            finished: false,
-            outputFile: await outputFile(this.config, download.suggestedFilename())
-        };
-        this._downloads.push(entry);
-        await download.saveAs(entry.outputFile);
-        entry.finished = true;
+    async outputFile(name) {
+        return outputFile(this.config, this._clientInfo.rootPath, name);
     }
     _onPageCreated(page) {
         const tab = new Tab(this, page, tab => this._onPageClosed(tab));
@@ -233,7 +94,6 @@ ${code.join('\n')}
             this._currentTab = tab;
     }
     _onPageClosed(tab) {
-        this._modalStates = this._modalStates.filter(state => state.tab !== tab);
         const index = this._tabs.indexOf(tab);
         if (index === -1)
             return;
@@ -241,9 +101,21 @@ ${code.join('\n')}
         if (this._currentTab === tab)
             this._currentTab = this._tabs[Math.min(index, this._tabs.length - 1)];
         if (!this._tabs.length)
-            void this.close();
+            void this.closeBrowserContext();
+    }
+    async closeBrowserContext() {
+        if (!this._closeBrowserContextPromise)
+            this._closeBrowserContextPromise = this._closeBrowserContextImpl().catch(logUnhandledError);
+        await this._closeBrowserContextPromise;
+        this._closeBrowserContextPromise = undefined;
+    }
+    isRunningTool() {
+        return this._isRunningTool;
     }
-    async close() {
+    setRunningTool(isRunningTool) {
+        this._isRunningTool = isRunningTool;
+    }
+    async _closeBrowserContextImpl() {
         if (!this._browserContextPromise)
             return;
         testDebug('close context');
@@ -255,6 +127,11 @@ ${code.join('\n')}
             await close();
         });
     }
+    async dispose() {
+        this._abortController.abort('MCP context disposed');
+        await this.closeBrowserContext();
+        Context._allContexts.delete(this);
+    }
     async _setupRequestInterception(context) {
         if (this.config.network?.allowedOrigins?.length) {
             await context.route('**', route => route.abort('blockedbyclient'));
@@ -276,10 +153,14 @@ ${code.join('\n')}
         return this._browserContextPromise;
     }
     async _setupBrowserContext() {
+        if (this._closeBrowserContextPromise)
+            throw new Error('Another browser context is being closed.');
         // TODO: move to the browser context factory to make it based on isolation mode.
-        const result = await this._browserContextFactory.createContext();
+        const result = await this._browserContextFactory.createContext(this._clientInfo, this._abortController.signal);
         const { browserContext } = result;
         await this._setupRequestInterception(browserContext);
+        if (this.sessionLog)
+            await InputRecorder.create(this, browserContext);
         for (const page of browserContext.pages())
             this._onPageCreated(page);
         browserContext.on('page', page => this._onPageCreated(page));
@@ -294,8 +175,52 @@ ${code.join('\n')}
         return result;
     }
 }
-function trim(text, maxLength) {
-    if (text.length <= maxLength)
-        return text;
-    return text.slice(0, maxLength) + '...';
+export class InputRecorder {
+    _context;
+    _browserContext;
+    constructor(context, browserContext) {
+        this._context = context;
+        this._browserContext = browserContext;
+    }
+    static async create(context, browserContext) {
+        const recorder = new InputRecorder(context, browserContext);
+        await recorder._initialize();
+        return recorder;
+    }
+    async _initialize() {
+        const sessionLog = this._context.sessionLog;
+        await this._browserContext._enableRecorder({
+            mode: 'recording',
+            recorderMode: 'api',
+        }, {
+            actionAdded: (page, data, code) => {
+                if (this._context.isRunningTool())
+                    return;
+                const tab = Tab.forPage(page);
+                if (tab)
+                    sessionLog.logUserAction(data.action, tab, code, false);
+            },
+            actionUpdated: (page, data, code) => {
+                if (this._context.isRunningTool())
+                    return;
+                const tab = Tab.forPage(page);
+                if (tab)
+                    sessionLog.logUserAction(data.action, tab, code, true);
+            },
+            signalAdded: (page, data) => {
+                if (this._context.isRunningTool())
+                    return;
+                if (data.signal.name !== 'navigation')
+                    return;
+                const tab = Tab.forPage(page);
+                const navigateAction = {
+                    name: 'navigate',
+                    url: data.signal.url,
+                    signals: [],
+                };
+                if (tab)
+                    sessionLog.logUserAction(navigateAction, tab, `await page.goto('${data.signal.url}');`, false);
+            },
+        });
+    }
 }