@playwright/mcp 0.0.31 → 0.0.33

package/lib/mcp/inProcessTransport.js

@@ -0,0 +1,72 @@
+/**
+ * Copyright (c) Microsoft Corporation.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+export class InProcessTransport {
+    _server;
+    _serverTransport;
+    _connected = false;
+    constructor(server) {
+        this._server = server;
+        this._serverTransport = new InProcessServerTransport(this);
+    }
+    async start() {
+        if (this._connected)
+            throw new Error('InprocessTransport already started!');
+        await this._server.connect(this._serverTransport);
+        this._connected = true;
+    }
+    async send(message, options) {
+        if (!this._connected)
+            throw new Error('Transport not connected');
+        this._serverTransport._receiveFromClient(message);
+    }
+    async close() {
+        if (this._connected) {
+            this._connected = false;
+            this.onclose?.();
+            this._serverTransport.onclose?.();
+        }
+    }
+    onclose;
+    onerror;
+    onmessage;
+    sessionId;
+    setProtocolVersion;
+    _receiveFromServer(message, extra) {
+        this.onmessage?.(message, extra);
+    }
+}
+class InProcessServerTransport {
+    _clientTransport;
+    constructor(clientTransport) {
+        this._clientTransport = clientTransport;
+    }
+    async start() {
+    }
+    async send(message, options) {
+        this._clientTransport._receiveFromServer(message);
+    }
+    async close() {
+        this.onclose?.();
+    }
+    onclose;
+    onerror;
+    onmessage;
+    sessionId;
+    setProtocolVersion;
+    _receiveFromClient(message) {
+        this.onmessage?.(message);
+    }
+}

package/lib/mcp/server.js

@@ -0,0 +1,93 @@
+/**
+ * Copyright (c) Microsoft Corporation.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+import { Server } from '@modelcontextprotocol/sdk/server/index.js';
+import { CallToolRequestSchema, ListToolsRequestSchema } from '@modelcontextprotocol/sdk/types.js';
+import { zodToJsonSchema } from 'zod-to-json-schema';
+import { ManualPromise } from '../manualPromise.js';
+import { logUnhandledError } from '../log.js';
+export async function connect(serverBackendFactory, transport, runHeartbeat) {
+    const backend = serverBackendFactory();
+    const server = createServer(backend, runHeartbeat);
+    await server.connect(transport);
+}
+export function createServer(backend, runHeartbeat) {
+    const initializedPromise = new ManualPromise();
+    const server = new Server({ name: backend.name, version: backend.version }, {
+        capabilities: {
+            tools: {},
+        }
+    });
+    const tools = backend.tools();
+    server.setRequestHandler(ListToolsRequestSchema, async () => {
+        return { tools: tools.map(tool => ({
+                name: tool.name,
+                description: tool.description,
+                inputSchema: zodToJsonSchema(tool.inputSchema),
+                annotations: {
+                    title: tool.title,
+                    readOnlyHint: tool.type === 'readOnly',
+                    destructiveHint: tool.type === 'destructive',
+                    openWorldHint: true,
+                },
+            })) };
+    });
+    let heartbeatRunning = false;
+    server.setRequestHandler(CallToolRequestSchema, async (request) => {
+        await initializedPromise;
+        if (runHeartbeat && !heartbeatRunning) {
+            heartbeatRunning = true;
+            startHeartbeat(server);
+        }
+        const errorResult = (...messages) => ({
+            content: [{ type: 'text', text: '### Result\n' + messages.join('\n') }],
+            isError: true,
+        });
+        const tool = tools.find(tool => tool.name === request.params.name);
+        if (!tool)
+            return errorResult(`Error: Tool "${request.params.name}" not found`);
+        try {
+            return await backend.callTool(tool, tool.inputSchema.parse(request.params.arguments || {}));
+        }
+        catch (error) {
+            return errorResult(String(error));
+        }
+    });
+    addServerListener(server, 'initialized', () => {
+        backend.initialize?.(server).then(() => initializedPromise.resolve()).catch(logUnhandledError);
+    });
+    addServerListener(server, 'close', () => backend.serverClosed?.());
+    return server;
+}
+const startHeartbeat = (server) => {
+    const beat = () => {
+        Promise.race([
+            server.ping(),
+            new Promise((_, reject) => setTimeout(() => reject(new Error('ping timeout')), 5000)),
+        ]).then(() => {
+            setTimeout(beat, 3000);
+        }).catch(() => {
+            void server.close();
+        });
+    };
+    beat();
+};
+function addServerListener(server, event, listener) {
+    const oldListener = server[`on${event}`];
+    server[`on${event}`] = () => {
+        oldListener?.();
+        listener();
+    };
+}

package/lib/{transport.js → mcp/transport.js}

@@ -13,18 +13,27 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-import http from 'node:http';
-import assert from 'node:assert';
-import crypto from 'node:crypto';
+import crypto from 'crypto';
 import debug from 'debug';
 import { SSEServerTransport } from '@modelcontextprotocol/sdk/server/sse.js';
 import { StreamableHTTPServerTransport } from '@modelcontextprotocol/sdk/server/streamableHttp.js';
 import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
-export async function startStdioTransport(server) {
-    await server.createConnection(new StdioServerTransport());
+import { httpAddressToString, startHttpServer } from '../httpServer.js';
+import * as mcpServer from './server.js';
+export async function start(serverBackendFactory, options) {
+    if (options.port !== undefined) {
+        const httpServer = await startHttpServer(options);
+        startHttpTransport(httpServer, serverBackendFactory);
+    }
+    else {
+        await startStdioTransport(serverBackendFactory);
+    }
+}
+async function startStdioTransport(serverBackendFactory) {
+    await mcpServer.connect(serverBackendFactory, new StdioServerTransport(), false);
 }
 const testDebug = debug('pw:mcp:test');
-async function handleSSE(server, req, res, url, sessions) {
+async function handleSSE(serverBackendFactory, req, res, url, sessions) {
     if (req.method === 'POST') {
         const sessionId = url.searchParams.get('sessionId');
         if (!sessionId) {
@@ -42,19 +51,17 @@ async function handleSSE(server, req, res, url, sessions) {
         const transport = new SSEServerTransport('/sse', res);
         sessions.set(transport.sessionId, transport);
         testDebug(`create SSE session: ${transport.sessionId}`);
-        const connection = await server.createConnection(transport);
+        await mcpServer.connect(serverBackendFactory, transport, false);
         res.on('close', () => {
             testDebug(`delete SSE session: ${transport.sessionId}`);
             sessions.delete(transport.sessionId);
-            // eslint-disable-next-line no-console
-            void connection.close().catch(e => console.error(e));
         });
         return;
     }
     res.statusCode = 405;
     res.end('Method not allowed');
 }
-async function handleStreamable(server, req, res, sessions) {
+async function handleStreamable(serverBackendFactory, req, res, sessions) {
     const sessionId = req.headers['mcp-session-id'];
     if (sessionId) {
         const transport = sessions.get(sessionId);
@@ -68,42 +75,33 @@ async function handleStreamable(server, req, res, sessions) {
     if (req.method === 'POST') {
         const transport = new StreamableHTTPServerTransport({
             sessionIdGenerator: () => crypto.randomUUID(),
-            onsessioninitialized: sessionId => {
+            onsessioninitialized: async (sessionId) => {
+                testDebug(`create http session: ${transport.sessionId}`);
+                await mcpServer.connect(serverBackendFactory, transport, true);
                 sessions.set(sessionId, transport);
             }
         });
         transport.onclose = () => {
-            if (transport.sessionId)
-                sessions.delete(transport.sessionId);
+            if (!transport.sessionId)
+                return;
+            sessions.delete(transport.sessionId);
+            testDebug(`delete http session: ${transport.sessionId}`);
         };
-        await server.createConnection(transport);
         await transport.handleRequest(req, res);
         return;
     }
     res.statusCode = 400;
     res.end('Invalid request');
 }
-export async function startHttpServer(config) {
-    const { host, port } = config;
-    const httpServer = http.createServer();
-    await new Promise((resolve, reject) => {
-        httpServer.on('error', reject);
-        httpServer.listen(port, host, () => {
-            resolve();
-            httpServer.removeListener('error', reject);
-        });
-    });
-    return httpServer;
-}
-export function startHttpTransport(httpServer, mcpServer) {
+function startHttpTransport(httpServer, serverBackendFactory) {
     const sseSessions = new Map();
     const streamableSessions = new Map();
     httpServer.on('request', async (req, res) => {
         const url = new URL(`http://localhost${req.url}`);
-        if (url.pathname.startsWith('/mcp'))
-            await handleStreamable(mcpServer, req, res, streamableSessions);
+        if (url.pathname.startsWith('/sse'))
+            await handleSSE(serverBackendFactory, req, res, url, sseSessions);
         else
-            await handleSSE(mcpServer, req, res, url, sseSessions);
+            await handleStreamable(serverBackendFactory, req, res, streamableSessions);
     });
     const url = httpAddressToString(httpServer.address());
     const message = [
@@ -112,22 +110,12 @@ export function startHttpTransport(httpServer, mcpServer) {
         JSON.stringify({
             'mcpServers': {
                 'playwright': {
-                    'url': `${url}/sse`
+                    'url': `${url}/mcp`
                 }
             }
         }, undefined, 2),
-        'If your client supports streamable HTTP, you can use the /mcp endpoint instead.',
+        'For legacy SSE transport support, you can use the /sse endpoint instead.',
     ].join('\n');
     // eslint-disable-next-line no-console
     console.error(message);
 }
-export function httpAddressToString(address) {
-    assert(address, 'Could not bind server socket');
-    if (typeof address === 'string')
-        return address;
-    const resolvedPort = address.port;
-    let resolvedHost = address.family === 'IPv4' ? address.address : `[${address.address}]`;
-    if (resolvedHost === '0.0.0.0' || resolvedHost === '[::]')
-        resolvedHost = 'localhost';
-    return `http://${resolvedHost}:${resolvedPort}`;
-}

package/lib/package.js

@@ -13,8 +13,8 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-import fs from 'node:fs';
-import url from 'node:url';
-import path from 'node:path';
+import fs from 'fs';
+import path from 'path';
+import url from 'url';
 const __filename = url.fileURLToPath(import.meta.url);
 export const packageJSON = JSON.parse(fs.readFileSync(path.join(path.dirname(__filename), '..', 'package.json'), 'utf8'));

package/lib/program.js

@@ -16,10 +16,14 @@
 import { program, Option } from 'commander';
 // @ts-ignore
 import { startTraceViewerServer } from 'playwright-core/lib/server';
-import { startHttpServer, startHttpTransport, startStdioTransport } from './transport.js';
+import * as mcpTransport from './mcp/transport.js';
 import { commaSeparatedList, resolveCLIConfig, semicolonSeparatedList } from './config.js';
-import { Server } from './server.js';
 import { packageJSON } from './package.js';
+import { createExtensionContextFactory, runWithExtension } from './extension/main.js';
+import { BrowserServerBackend } from './browserServerBackend.js';
+import { Context } from './context.js';
+import { contextFactory } from './browserContextFactory.js';
+import { runLoopTools } from './loopTools/main.js';
 program
     .version('Version ' + packageJSON.version)
     .name(packageJSON.name)
@@ -42,26 +46,38 @@ program
     .option('--port <port>', 'port to listen on for SSE transport.')
     .option('--proxy-bypass <bypass>', 'comma-separated domains to bypass proxy, for example ".com,chromium.org,.domain.com"')
     .option('--proxy-server <proxy>', 'specify proxy server, for example "http://myproxy:3128" or "socks5://myproxy:8080"')
+    .option('--save-session', 'Whether to save the Playwright MCP session into the output directory.')
     .option('--save-trace', 'Whether to save the Playwright Trace of the session into the output directory.')
     .option('--storage-state <path>', 'path to the storage state file for isolated sessions.')
     .option('--user-agent <ua string>', 'specify user agent string')
     .option('--user-data-dir <path>', 'path to the user data directory. If not specified, a temporary directory will be created.')
     .option('--viewport-size <size>', 'specify browser viewport size in pixels, for example "1280, 720"')
+    .addOption(new Option('--extension', 'Connect to a running browser instance (Edge/Chrome only). Requires the "Playwright MCP Bridge" browser extension to be installed.').hideHelp())
+    .addOption(new Option('--connect-tool', 'Allow to switch between different browser connection methods.').hideHelp())
+    .addOption(new Option('--loop-tools', 'Run loop tools').hideHelp())
     .addOption(new Option('--vision', 'Legacy option, use --caps=vision instead').hideHelp())
     .action(async (options) => {
+    setupExitWatchdog();
     if (options.vision) {
         // eslint-disable-next-line no-console
         console.error('The --vision option is deprecated, use --caps=vision instead');
         options.caps = 'vision';
     }
     const config = await resolveCLIConfig(options);
-    const httpServer = config.server.port !== undefined ? await startHttpServer(config.server) : undefined;
-    const server = new Server(config);
-    server.setupExitWatchdog();
-    if (httpServer)
-        startHttpTransport(httpServer, server);
-    else
-        await startStdioTransport(server);
+    if (options.extension) {
+        await runWithExtension(config);
+        return;
+    }
+    if (options.loopTools) {
+        await runLoopTools(config);
+        return;
+    }
+    const browserContextFactory = contextFactory(config);
+    const factories = [browserContextFactory];
+    if (options.connectTool)
+        factories.push(createExtensionContextFactory(config));
+    const serverBackendFactory = () => new BrowserServerBackend(config, factories);
+    await mcpTransport.start(serverBackendFactory, config.server);
     if (config.saveTrace) {
         const server = await startTraceViewerServer();
         const urlPrefix = server.urlPrefix('human-readable');
@@ -70,4 +86,18 @@ program
         console.error('\nTrace viewer listening on ' + url);
     }
 });
+function setupExitWatchdog() {
+    let isExiting = false;
+    const handleExit = async () => {
+        if (isExiting)
+            return;
+        isExiting = true;
+        setTimeout(() => process.exit(0), 15000);
+        await Context.disposeAll();
+        process.exit(0);
+    };
+    process.stdin.on('close', handleExit);
+    process.on('SIGINT', handleExit);
+    process.on('SIGTERM', handleExit);
+}
 void program.parseAsync(process.argv);

package/lib/response.js

@@ -0,0 +1,165 @@
+/**
+ * Copyright (c) Microsoft Corporation.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+import { renderModalStates } from './tab.js';
+export class Response {
+    _result = [];
+    _code = [];
+    _images = [];
+    _context;
+    _includeSnapshot = false;
+    _includeTabs = false;
+    _tabSnapshot;
+    toolName;
+    toolArgs;
+    _isError;
+    constructor(context, toolName, toolArgs) {
+        this._context = context;
+        this.toolName = toolName;
+        this.toolArgs = toolArgs;
+    }
+    addResult(result) {
+        this._result.push(result);
+    }
+    addError(error) {
+        this._result.push(error);
+        this._isError = true;
+    }
+    isError() {
+        return this._isError;
+    }
+    result() {
+        return this._result.join('\n');
+    }
+    addCode(code) {
+        this._code.push(code);
+    }
+    code() {
+        return this._code.join('\n');
+    }
+    addImage(image) {
+        this._images.push(image);
+    }
+    images() {
+        return this._images;
+    }
+    setIncludeSnapshot() {
+        this._includeSnapshot = true;
+    }
+    setIncludeTabs() {
+        this._includeTabs = true;
+    }
+    async finish() {
+        // All the async snapshotting post-action is happening here.
+        // Everything below should race against modal states.
+        if (this._includeSnapshot && this._context.currentTab())
+            this._tabSnapshot = await this._context.currentTabOrDie().captureSnapshot();
+        for (const tab of this._context.tabs())
+            await tab.updateTitle();
+    }
+    tabSnapshot() {
+        return this._tabSnapshot;
+    }
+    serialize() {
+        const response = [];
+        // Start with command result.
+        if (this._result.length) {
+            response.push('### Result');
+            response.push(this._result.join('\n'));
+            response.push('');
+        }
+        // Add code if it exists.
+        if (this._code.length) {
+            response.push(`### Ran Playwright code
+\`\`\`js
+${this._code.join('\n')}
+\`\`\``);
+            response.push('');
+        }
+        // List browser tabs.
+        if (this._includeSnapshot || this._includeTabs)
+            response.push(...renderTabsMarkdown(this._context.tabs(), this._includeTabs));
+        // Add snapshot if provided.
+        if (this._tabSnapshot?.modalStates.length) {
+            response.push(...renderModalStates(this._context, this._tabSnapshot.modalStates));
+            response.push('');
+        }
+        else if (this._tabSnapshot) {
+            response.push(renderTabSnapshot(this._tabSnapshot));
+            response.push('');
+        }
+        // Main response part
+        const content = [
+            { type: 'text', text: response.join('\n') },
+        ];
+        // Image attachments.
+        if (this._context.config.imageResponses !== 'omit') {
+            for (const image of this._images)
+                content.push({ type: 'image', data: image.data.toString('base64'), mimeType: image.contentType });
+        }
+        return { content, isError: this._isError };
+    }
+}
+function renderTabSnapshot(tabSnapshot) {
+    const lines = [];
+    if (tabSnapshot.consoleMessages.length) {
+        lines.push(`### New console messages`);
+        for (const message of tabSnapshot.consoleMessages)
+            lines.push(`- ${trim(message.toString(), 100)}`);
+        lines.push('');
+    }
+    if (tabSnapshot.downloads.length) {
+        lines.push(`### Downloads`);
+        for (const entry of tabSnapshot.downloads) {
+            if (entry.finished)
+                lines.push(`- Downloaded file ${entry.download.suggestedFilename()} to ${entry.outputFile}`);
+            else
+                lines.push(`- Downloading file ${entry.download.suggestedFilename()} ...`);
+        }
+        lines.push('');
+    }
+    lines.push(`### Page state`);
+    lines.push(`- Page URL: ${tabSnapshot.url}`);
+    lines.push(`- Page Title: ${tabSnapshot.title}`);
+    lines.push(`- Page Snapshot:`);
+    lines.push('```yaml');
+    lines.push(tabSnapshot.ariaSnapshot);
+    lines.push('```');
+    return lines.join('\n');
+}
+function renderTabsMarkdown(tabs, force = false) {
+    if (tabs.length === 1 && !force)
+        return [];
+    if (!tabs.length) {
+        return [
+            '### Open tabs',
+            'No open tabs. Use the "browser_navigate" tool to navigate to a page first.',
+            '',
+        ];
+    }
+    const lines = ['### Open tabs'];
+    for (let i = 0; i < tabs.length; i++) {
+        const tab = tabs[i];
+        const current = tab.isCurrentTab() ? ' (current)' : '';
+        lines.push(`- ${i}:${current} [${tab.lastTitle()}] (${tab.page.url()})`);
+    }
+    lines.push('');
+    return lines;
+}
+function trim(text, maxLength) {
+    if (text.length <= maxLength)
+        return text;
+    return text.slice(0, maxLength) + '...';
+}

package/lib/sessionLog.js

@@ -0,0 +1,121 @@
+/**
+ * Copyright (c) Microsoft Corporation.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+import fs from 'fs';
+import path from 'path';
+import { logUnhandledError } from './log.js';
+import { outputFile } from './config.js';
+export class SessionLog {
+    _folder;
+    _file;
+    _ordinal = 0;
+    _pendingEntries = [];
+    _sessionFileQueue = Promise.resolve();
+    _flushEntriesTimeout;
+    constructor(sessionFolder) {
+        this._folder = sessionFolder;
+        this._file = path.join(this._folder, 'session.md');
+    }
+    static async create(config, rootPath) {
+        const sessionFolder = await outputFile(config, rootPath, `session-${Date.now()}`);
+        await fs.promises.mkdir(sessionFolder, { recursive: true });
+        // eslint-disable-next-line no-console
+        console.error(`Session: ${sessionFolder}`);
+        return new SessionLog(sessionFolder);
+    }
+    logResponse(response) {
+        const entry = {
+            timestamp: performance.now(),
+            toolCall: {
+                toolName: response.toolName,
+                toolArgs: response.toolArgs,
+                result: response.result(),
+                isError: response.isError(),
+            },
+            code: response.code(),
+            tabSnapshot: response.tabSnapshot(),
+        };
+        this._appendEntry(entry);
+    }
+    logUserAction(action, tab, code, isUpdate) {
+        code = code.trim();
+        if (isUpdate) {
+            const lastEntry = this._pendingEntries[this._pendingEntries.length - 1];
+            if (lastEntry.userAction?.name === action.name) {
+                lastEntry.userAction = action;
+                lastEntry.code = code;
+                return;
+            }
+        }
+        if (action.name === 'navigate') {
+            // Already logged at this location.
+            const lastEntry = this._pendingEntries[this._pendingEntries.length - 1];
+            if (lastEntry?.tabSnapshot?.url === action.url)
+                return;
+        }
+        const entry = {
+            timestamp: performance.now(),
+            userAction: action,
+            code,
+            tabSnapshot: {
+                url: tab.page.url(),
+                title: '',
+                ariaSnapshot: action.ariaSnapshot || '',
+                modalStates: [],
+                consoleMessages: [],
+                downloads: [],
+            },
+        };
+        this._appendEntry(entry);
+    }
+    _appendEntry(entry) {
+        this._pendingEntries.push(entry);
+        if (this._flushEntriesTimeout)
+            clearTimeout(this._flushEntriesTimeout);
+        this._flushEntriesTimeout = setTimeout(() => this._flushEntries(), 1000);
+    }
+    async _flushEntries() {
+        clearTimeout(this._flushEntriesTimeout);
+        const entries = this._pendingEntries;
+        this._pendingEntries = [];
+        const lines = [''];
+        for (const entry of entries) {
+            const ordinal = (++this._ordinal).toString().padStart(3, '0');
+            if (entry.toolCall) {
+                lines.push(`### Tool call: ${entry.toolCall.toolName}`, `- Args`, '```json', JSON.stringify(entry.toolCall.toolArgs, null, 2), '```');
+                if (entry.toolCall.result) {
+                    lines.push(entry.toolCall.isError ? `- Error` : `- Result`, '```', entry.toolCall.result, '```');
+                }
+            }
+            if (entry.userAction) {
+                const actionData = { ...entry.userAction };
+                delete actionData.ariaSnapshot;
+                delete actionData.selector;
+                delete actionData.signals;
+                lines.push(`### User action: ${entry.userAction.name}`, `- Args`, '```json', JSON.stringify(actionData, null, 2), '```');
+            }
+            if (entry.code) {
+                lines.push(`- Code`, '```js', entry.code, '```');
+            }
+            if (entry.tabSnapshot) {
+                const fileName = `${ordinal}.snapshot.yml`;
+                fs.promises.writeFile(path.join(this._folder, fileName), entry.tabSnapshot.ariaSnapshot).catch(logUnhandledError);
+                lines.push(`- Snapshot: ${fileName}`);
+            }
+            lines.push('', '');
+        }
+        this._sessionFileQueue = this._sessionFileQueue.then(() => fs.promises.appendFile(this._file, lines.join('\n')));
+    }
+}