Playwright is a framework for Web Testing and Automation. It allows testing Chromium, Firefox and WebKit with a single API.
TypeScript automationchromechromiume2e-testingelectronend-to-end-testingfirefoxjavascriptplaywrighttesttest-automationtestingtesting-toolswebwebkit
chore(cli): add cookie/storage commands (#39070)
Pavel Feldman824f63da57ed
diff --git a/.claude/skills/playwright-mcp-dev/SKILL.md b/.claude/skills/playwright-mcp-dev/SKILL.mdnew file mode 100644index 0000000000..a98bacc5a2--- /dev/null+++ b/.claude/skills/playwright-mcp-dev/SKILL.md@@ -0,0 +1,33 @@+---+name: playwright-mcp-dev+description: Explains how to add and debug playwright MCP tools and CLI commands.+---++# MCP++## Adding MCP Tools+- Create a new tool in `packages/playwright/src/mcp/browser/tools/your-tool.ts`+- Register the tool in `packages/playwright/src/mcp/browser/tools.ts`+- Add ToolCapability in `packages/playwright/src/mcp/config.d.ts`+- Place new tests in `tests/mcp/mcp-<category>.spec.ts`++## Testing+- Run tests as `npm run ctest-mcp <category>`++# CLI++## Adding commands+- CLI commands are based on MCP tools. Implement the corresponding MCP tool as per `Adding MCP Tools` section above, if needed.+- Add new CLI category for tool if needed:+ - Add Category in `packages/playwright/src/mcp/terminal/command.ts`+ - Update doc generator `packages/playwright/src/mcp/terminal/helpGenerator.ts`+- Register command in `packages/playwright/src/mcp/terminal/commands.ts`+- Update skill file at `packages/playwright/src/skill/SKILL.md` and references if necessary+ in `packages/playwright/src/skill/references/`+- Place new tests in `tests/mcp/cli-<category>.spec.ts`++## Testing+- Run tests as `npm run ctest-mcp cli-<category>`++# Lint+- run `npm run flint:mcp` to lint everything before commitdiff --git a/.github/workflows/tests_mcp.yml b/.github/workflows/tests_mcp.ymlindex b38e3ad86a..5c5b7d537e 100644--- a/.github/workflows/tests_mcp.yml+++ b/.github/workflows/tests_mcp.yml@@ -23,7 +23,6 @@ env:# Force terminal colors. @see https://www.npmjs.com/package/colorsFORCE_COLOR: 1ELECTRON_SKIP_BINARY_DOWNLOAD: 1- PWDEBUGIMPL: 1DEBUG: pw:mcp:errorjobs:diff --git a/packages/playwright/src/mcp/browser/tools.ts b/packages/playwright/src/mcp/browser/tools.tsindex a70cd5af35..0cf5c03197 100644--- a/packages/playwright/src/mcp/browser/tools.ts+++ b/packages/playwright/src/mcp/browser/tools.ts@@ -16,6 +16,7 @@import common from './tools/common';import console from './tools/console';+import cookies from './tools/cookies';import dialogs from './tools/dialogs';import evaluate from './tools/evaluate';import files from './tools/files';@@ -35,6 +36,7 @@ import tracing from './tools/tracing';import verify from './tools/verify';import video from './tools/video';import wait from './tools/wait';+import webstorage from './tools/webstorage';import type { Tool } from './tools/tool';import type { FullConfig } from './config';@@ -42,6 +44,7 @@ import type { FullConfig } from './config';export const browserTools: Tool<any>[] = [...common,...console,+ ...cookies,...dialogs,...evaluate,...files,@@ -61,6 +64,7 @@ export const browserTools: Tool<any>[] = [...verify,...video,...wait,+ ...webstorage,];export function filteredTools(config: FullConfig) {diff --git a/packages/playwright/src/mcp/browser/tools/cookies.ts b/packages/playwright/src/mcp/browser/tools/cookies.tsnew file mode 100644index 0000000000..ec7fc0d928--- /dev/null+++ b/packages/playwright/src/mcp/browser/tools/cookies.ts@@ -0,0 +1,168 @@+/**+ * 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 { z } from 'playwright-core/lib/mcpBundle';+import { defineTool } from './tool';++const cookieList = defineTool({+ capability: 'storage',++ schema: {+ name: 'browser_cookie_list',+ title: 'List cookies',+ description: 'List all cookies (optionally filtered by domain/path)',+ inputSchema: z.object({+ domain: z.string().optional().describe('Filter cookies by domain'),+ path: z.string().optional().describe('Filter cookies by path'),+ }),+ type: 'readOnly',+ },++ handle: async (context, params, response) => {+ const browserContext = await context.ensureBrowserContext();+ let cookies = await browserContext.cookies();++ if (params.domain)+ cookies = cookies.filter(c => c.domain.includes(params.domain!));+ if (params.path)+ cookies = cookies.filter(c => c.path.startsWith(params.path!));++ if (cookies.length === 0)+ response.addTextResult('No cookies found');+ else+ response.addTextResult(cookies.map(c => `${c.name}=${c.value} (domain: ${c.domain}, path: ${c.path})`).join('\n'));+ response.addCode(`await page.context().cookies();`);+ },+});++const cookieGet = defineTool({+ capability: 'storage',++ schema: {+ name: 'browser_cookie_get',+ title: 'Get cookie',+ description: 'Get a specific cookie by name',+ inputSchema: z.object({+ name: z.string().describe('Cookie name to get'),+ }),+ type: 'readOnly',+ },++ handle: async (context, params, response) => {+ const browserContext = await context.ensureBrowserContext();+ const cookies = await browserContext.cookies();+ const cookie = cookies.find(c => c.name === params.name);++ if (!cookie)+ response.addTextResult(`Cookie '${params.name}' not found`);+ else+ response.addTextResult(`${cookie.name}=${cookie.value} (domain: ${cookie.domain}, path: ${cookie.path}, httpOnly: ${cookie.httpOnly}, secure: ${cookie.secure}, sameSite: ${cookie.sameSite})`);+ response.addCode(`await page.context().cookies();`);+ },+});++const cookieSet = defineTool({+ capability: 'storage',++ schema: {+ name: 'browser_cookie_set',+ title: 'Set cookie',+ description: 'Set a cookie with optional flags (domain, path, expires, httpOnly, secure, sameSite)',+ inputSchema: z.object({+ name: z.string().describe('Cookie name'),+ value: z.string().describe('Cookie value'),+ domain: z.string().optional().describe('Cookie domain'),+ path: z.string().optional().describe('Cookie path'),+ expires: z.number().optional().describe('Cookie expiration as Unix timestamp'),+ httpOnly: z.boolean().optional().describe('Whether the cookie is HTTP only'),+ secure: z.boolean().optional().describe('Whether the cookie is secure'),+ sameSite: z.enum(['Strict', 'Lax', 'None']).optional().describe('Cookie SameSite attribute'),+ }),+ type: 'action',+ },++ handle: async (context, params, response) => {+ const browserContext = await context.ensureBrowserContext();+ const tab = await context.ensureTab();++ // Get the current page URL to determine default domain+ const url = new URL(tab.page.url());+ const cookie: any = {+ name: params.name,+ value: params.value,+ domain: params.domain || url.hostname,+ path: params.path || '/',+ };++ if (params.expires !== undefined)+ cookie.expires = params.expires;+ if (params.httpOnly !== undefined)+ cookie.httpOnly = params.httpOnly;+ if (params.secure !== undefined)+ cookie.secure = params.secure;+ if (params.sameSite !== undefined)+ cookie.sameSite = params.sameSite;++ await browserContext.addCookies([cookie]);+ response.addCode(`await page.context().addCookies([${JSON.stringify(cookie)}]);`);+ },+});++const cookieDelete = defineTool({+ capability: 'storage',++ schema: {+ name: 'browser_cookie_delete',+ title: 'Delete cookie',+ description: 'Delete a specific cookie',+ inputSchema: z.object({+ name: z.string().describe('Cookie name to delete'),+ }),+ type: 'action',+ },++ handle: async (context, params, response) => {+ const browserContext = await context.ensureBrowserContext();+ await browserContext.clearCookies({ name: params.name });+ response.addCode(`await page.context().clearCookies({ name: '${params.name}' });`);+ },+});++const cookieClear = defineTool({+ capability: 'storage',++ schema: {+ name: 'browser_cookie_clear',+ title: 'Clear cookies',+ description: 'Clear all cookies',+ inputSchema: z.object({}),+ type: 'action',+ },++ handle: async (context, params, response) => {+ const browserContext = await context.ensureBrowserContext();+ await browserContext.clearCookies();+ response.addCode(`await page.context().clearCookies();`);+ },+});++export default [+ cookieList,+ cookieGet,+ cookieSet,+ cookieDelete,+ cookieClear,+];diff --git a/packages/playwright/src/mcp/browser/tools/webstorage.ts b/packages/playwright/src/mcp/browser/tools/webstorage.tsnew file mode 100644index 0000000000..f999f356d8--- /dev/null+++ b/packages/playwright/src/mcp/browser/tools/webstorage.ts@@ -0,0 +1,253 @@+/**+ * 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 { z } from 'playwright-core/lib/mcpBundle';+import { defineTabTool } from './tool';++const localStorageList = defineTabTool({+ capability: 'storage',++ schema: {+ name: 'browser_localstorage_list',+ title: 'List localStorage',+ description: 'List all localStorage key-value pairs',+ inputSchema: z.object({}),+ type: 'readOnly',+ },++ handle: async (tab, params, response) => {+ const items = await tab.page.evaluate(() => {+ const result: { key: string; value: string }[] = [];+ for (let i = 0; i < localStorage.length; i++) {+ const key = localStorage.key(i);+ if (key !== null)+ result.push({ key, value: localStorage.getItem(key) || '' });+ }+ return result;+ });++ if (items.length === 0)+ response.addTextResult('No localStorage items found');+ else+ response.addTextResult(items.map(item => `${item.key}=${item.value}`).join('\n'));+ response.addCode(`await page.evaluate(() => ({ ...localStorage }));`);+ },+});++const localStorageGet = defineTabTool({+ capability: 'storage',++ schema: {+ name: 'browser_localstorage_get',+ title: 'Get localStorage item',+ description: 'Get a localStorage item by key',+ inputSchema: z.object({+ key: z.string().describe('Key to get'),+ }),+ type: 'readOnly',+ },++ handle: async (tab, params, response) => {+ const value = await tab.page.evaluate(key => localStorage.getItem(key), params.key);++ if (value === null)+ response.addTextResult(`localStorage key '${params.key}' not found`);+ else+ response.addTextResult(`${params.key}=${value}`);+ response.addCode(`await page.evaluate(() => localStorage.getItem('${params.key}'));`);+ },+});++const localStorageSet = defineTabTool({+ capability: 'storage',++ schema: {+ name: 'browser_localstorage_set',+ title: 'Set localStorage item',+ description: 'Set a localStorage item',+ inputSchema: z.object({+ key: z.string().describe('Key to set'),+ value: z.string().describe('Value to set'),+ }),+ type: 'action',+ },++ handle: async (tab, params, response) => {+ await tab.page.evaluate(({ key, value }) => localStorage.setItem(key, value), params);+ response.addCode(`await page.evaluate(() => localStorage.setItem('${params.key}', '${params.value}'));`);+ },+});++const localStorageDelete = defineTabTool({+ capability: 'storage',++ schema: {+ name: 'browser_localstorage_delete',+ title: 'Delete localStorage item',+ description: 'Delete a localStorage item',+ inputSchema: z.object({+ key: z.string().describe('Key to delete'),+ }),+ type: 'action',+ },++ handle: async (tab, params, response) => {+ await tab.page.evaluate(key => localStorage.removeItem(key), params.key);+ response.addCode(`await page.evaluate(() => localStorage.removeItem('${params.key}'));`);+ },+});++const localStorageClear = defineTabTool({+ capability: 'storage',++ schema: {+ name: 'browser_localstorage_clear',+ title: 'Clear localStorage',+ description: 'Clear all localStorage',+ inputSchema: z.object({}),+ type: 'action',+ },++ handle: async (tab, params, response) => {+ await tab.page.evaluate(() => localStorage.clear());+ response.addCode(`await page.evaluate(() => localStorage.clear());`);+ },+});++// SessionStorage++const sessionStorageList = defineTabTool({+ capability: 'storage',++ schema: {+ name: 'browser_sessionstorage_list',+ title: 'List sessionStorage',+ description: 'List all sessionStorage key-value pairs',+ inputSchema: z.object({}),+ type: 'readOnly',+ },++ handle: async (tab, params, response) => {+ const items = await tab.page.evaluate(() => {+ const result: { key: string; value: string }[] = [];+ for (let i = 0; i < sessionStorage.length; i++) {+ const key = sessionStorage.key(i);+ if (key !== null)+ result.push({ key, value: sessionStorage.getItem(key) || '' });+ }+ return result;+ });++ if (items.length === 0)+ response.addTextResult('No sessionStorage items found');+ else+ response.addTextResult(items.map(item => `${item.key}=${item.value}`).join('\n'));+ response.addCode(`await page.evaluate(() => ({ ...sessionStorage }));`);+ },+});++const sessionStorageGet = defineTabTool({+ capability: 'storage',++ schema: {+ name: 'browser_sessionstorage_get',+ title: 'Get sessionStorage item',+ description: 'Get a sessionStorage item by key',+ inputSchema: z.object({+ key: z.string().describe('Key to get'),+ }),+ type: 'readOnly',+ },++ handle: async (tab, params, response) => {+ const value = await tab.page.evaluate(key => sessionStorage.getItem(key), params.key);++ if (value === null)+ response.addTextResult(`sessionStorage key '${params.key}' not found`);+ else+ response.addTextResult(`${params.key}=${value}`);+ response.addCode(`await page.evaluate(() => sessionStorage.getItem('${params.key}'));`);+ },+});++const sessionStorageSet = defineTabTool({+ capability: 'storage',++ schema: {+ name: 'browser_sessionstorage_set',+ title: 'Set sessionStorage item',+ description: 'Set a sessionStorage item',+ inputSchema: z.object({+ key: z.string().describe('Key to set'),+ value: z.string().describe('Value to set'),+ }),+ type: 'action',+ },++ handle: async (tab, params, response) => {+ await tab.page.evaluate(({ key, value }) => sessionStorage.setItem(key, value), params);+ response.addCode(`await page.evaluate(() => sessionStorage.setItem('${params.key}', '${params.value}'));`);+ },+});++const sessionStorageDelete = defineTabTool({+ capability: 'storage',++ schema: {+ name: 'browser_sessionstorage_delete',+ title: 'Delete sessionStorage item',+ description: 'Delete a sessionStorage item',+ inputSchema: z.object({+ key: z.string().describe('Key to delete'),+ }),+ type: 'action',+ },++ handle: async (tab, params, response) => {+ await tab.page.evaluate(key => sessionStorage.removeItem(key), params.key);+ response.addCode(`await page.evaluate(() => sessionStorage.removeItem('${params.key}'));`);+ },+});++const sessionStorageClear = defineTabTool({+ capability: 'storage',++ schema: {+ name: 'browser_sessionstorage_clear',+ title: 'Clear sessionStorage',+ description: 'Clear all sessionStorage',+ inputSchema: z.object({}),+ type: 'action',+ },++ handle: async (tab, params, response) => {+ await tab.page.evaluate(() => sessionStorage.clear());+ response.addCode(`await page.evaluate(() => sessionStorage.clear());`);+ },+});++export default [+ localStorageList,+ localStorageGet,+ localStorageSet,+ localStorageDelete,+ localStorageClear,+ sessionStorageList,+ sessionStorageGet,+ sessionStorageSet,+ sessionStorageDelete,+ sessionStorageClear,+];diff --git a/packages/playwright/src/mcp/terminal/commands.ts b/packages/playwright/src/mcp/terminal/commands.tsindex a76392a8f2..7f758941d0 100644--- a/packages/playwright/src/mcp/terminal/commands.ts+++ b/packages/playwright/src/mcp/terminal/commands.ts@@ -395,7 +395,7 @@ const tabSelect = declareCommand({const stateLoad = declareCommand({name: 'state-load',- description: 'Loads storage (authentication) state from a file',+ description: 'Loads browser storage (authentication) state from a file',category: 'storage',args: z.object({filename: z.string().describe('File name to load the storage state from.'),@@ -415,6 +415,180 @@ const stateSave = declareCommand({toolParams: ({ filename }) => ({ filename }),});+// Cookies++const cookieList = declareCommand({+ name: 'cookie-list',+ description: 'List all cookies (optionally filtered by domain/path)',+ category: 'storage',+ args: z.object({}),+ options: z.object({+ domain: z.string().optional().describe('Filter cookies by domain'),+ path: z.string().optional().describe('Filter cookies by path'),+ }),+ toolName: 'browser_cookie_list',+ toolParams: ({ domain, path }) => ({ domain, path }),+});++const cookieGet = declareCommand({+ name: 'cookie-get',+ description: 'Get a specific cookie by name',+ category: 'storage',+ args: z.object({+ name: z.string().describe('Cookie name'),+ }),+ toolName: 'browser_cookie_get',+ toolParams: ({ name }) => ({ name }),+});++const cookieSet = declareCommand({+ name: 'cookie-set',+ description: 'Set a cookie with optional flags',+ category: 'storage',+ args: z.object({+ name: z.string().describe('Cookie name'),+ value: z.string().describe('Cookie value'),+ }),+ options: z.object({+ domain: z.string().optional().describe('Cookie domain'),+ path: z.string().optional().describe('Cookie path'),+ expires: z.number().optional().describe('Cookie expiration as Unix timestamp'),+ httpOnly: z.boolean().optional().describe('Whether the cookie is HTTP only'),+ secure: z.boolean().optional().describe('Whether the cookie is secure'),+ sameSite: z.enum(['Strict', 'Lax', 'None']).optional().describe('Cookie SameSite attribute'),+ }),+ toolName: 'browser_cookie_set',+ toolParams: ({ name, value, domain, path, expires, httpOnly, secure, sameSite }) => ({ name, value, domain, path, expires, httpOnly, secure, sameSite }),+});++const cookieDelete = declareCommand({+ name: 'cookie-delete',+ description: 'Delete a specific cookie',+ category: 'storage',+ args: z.object({+ name: z.string().describe('Cookie name'),+ }),+ toolName: 'browser_cookie_delete',+ toolParams: ({ name }) => ({ name }),+});++const cookieClear = declareCommand({+ name: 'cookie-clear',+ description: 'Clear all cookies',+ category: 'storage',+ args: z.object({}),+ toolName: 'browser_cookie_clear',+ toolParams: () => ({}),+});++// LocalStorage++const localStorageList = declareCommand({+ name: 'localstorage-list',+ description: 'List all localStorage key-value pairs',+ category: 'storage',+ args: z.object({}),+ toolName: 'browser_localstorage_list',+ toolParams: () => ({}),+});++const localStorageGet = declareCommand({+ name: 'localstorage-get',+ description: 'Get a localStorage item by key',+ category: 'storage',+ args: z.object({+ key: z.string().describe('Key to get'),+ }),+ toolName: 'browser_localstorage_get',+ toolParams: ({ key }) => ({ key }),+});++const localStorageSet = declareCommand({+ name: 'localstorage-set',+ description: 'Set a localStorage item',+ category: 'storage',+ args: z.object({+ key: z.string().describe('Key to set'),+ value: z.string().describe('Value to set'),+ }),+ toolName: 'browser_localstorage_set',+ toolParams: ({ key, value }) => ({ key, value }),+});++const localStorageDelete = declareCommand({+ name: 'localstorage-delete',+ description: 'Delete a localStorage item',+ category: 'storage',+ args: z.object({+ key: z.string().describe('Key to delete'),+ }),+ toolName: 'browser_localstorage_delete',+ toolParams: ({ key }) => ({ key }),+});++const localStorageClear = declareCommand({+ name: 'localstorage-clear',+ description: 'Clear all localStorage',+ category: 'storage',+ args: z.object({}),+ toolName: 'browser_localstorage_clear',+ toolParams: () => ({}),+});++// SessionStorage++const sessionStorageList = declareCommand({+ name: 'sessionstorage-list',+ description: 'List all sessionStorage key-value pairs',+ category: 'storage',+ args: z.object({}),+ toolName: 'browser_sessionstorage_list',+ toolParams: () => ({}),+});++const sessionStorageGet = declareCommand({+ name: 'sessionstorage-get',+ description: 'Get a sessionStorage item by key',+ category: 'storage',+ args: z.object({+ key: z.string().describe('Key to get'),+ }),+ toolName: 'browser_sessionstorage_get',+ toolParams: ({ key }) => ({ key }),+});++const sessionStorageSet = declareCommand({+ name: 'sessionstorage-set',+ description: 'Set a sessionStorage item',+ category: 'storage',+ args: z.object({+ key: z.string().describe('Key to set'),+ value: z.string().describe('Value to set'),+ }),+ toolName: 'browser_sessionstorage_set',+ toolParams: ({ key, value }) => ({ key, value }),+});++const sessionStorageDelete = declareCommand({+ name: 'sessionstorage-delete',+ description: 'Delete a sessionStorage item',+ category: 'storage',+ args: z.object({+ key: z.string().describe('Key to delete'),+ }),+ toolName: 'browser_sessionstorage_delete',+ toolParams: ({ key }) => ({ key }),+});++const sessionStorageClear = declareCommand({+ name: 'sessionstorage-clear',+ description: 'Clear all sessionStorage',+ category: 'storage',+ args: z.object({}),+ toolName: 'browser_sessionstorage_clear',+ toolParams: () => ({}),+});+// Exportconst screenshot = declareCommand({@@ -639,6 +813,21 @@ const commandsArray: AnyCommandSchema[] = [// storage categorystateLoad,stateSave,+ cookieList,+ cookieGet,+ cookieSet,+ cookieDelete,+ cookieClear,+ localStorageList,+ localStorageGet,+ localStorageSet,+ localStorageDelete,+ localStorageClear,+ sessionStorageList,+ sessionStorageGet,+ sessionStorageSet,+ sessionStorageDelete,+ sessionStorageClear,// config categoryconfig,diff --git a/packages/playwright/src/mcp/terminal/program.ts b/packages/playwright/src/mcp/terminal/program.tsindex ca70a095f4..9457734be7 100644--- a/packages/playwright/src/mcp/terminal/program.ts+++ b/packages/playwright/src/mcp/terminal/program.ts@@ -491,7 +491,7 @@ export async function program(options: { version: string }) {}const sessionManager = await SessionManager.create(version, args);- if (commandName.startsWith('session')) {+ if (commandName.startsWith('session-')) {const subcommand = args._[0].split('-').slice(1).join('-');await handleSessionCommand(sessionManager, subcommand, args);return;diff --git a/packages/playwright/src/skill/SKILL.md b/packages/playwright/src/skill/SKILL.mdindex 24e060e893..422902d5ff 100644--- a/packages/playwright/src/skill/SKILL.md+++ b/packages/playwright/src/skill/SKILL.md@@ -100,6 +100,29 @@ playwright-cli tab-select 0playwright-cli state-saveplaywright-cli state-save auth.jsonplaywright-cli state-load auth.json++# Cookies+playwright-cli cookie-list+playwright-cli cookie-list --domain=example.com+playwright-cli cookie-get session_id+playwright-cli cookie-set session_id abc123+playwright-cli cookie-set session_id abc123 --domain=example.com --httpOnly --secure+playwright-cli cookie-delete session_id+playwright-cli cookie-clear++# LocalStorage+playwright-cli localstorage-list+playwright-cli localstorage-get theme+playwright-cli localstorage-set theme dark+playwright-cli localstorage-delete theme+playwright-cli localstorage-clear++# SessionStorage+playwright-cli sessionstorage-list+playwright-cli sessionstorage-get step+playwright-cli sessionstorage-set step 3+playwright-cli sessionstorage-delete step+playwright-cli sessionstorage-clear```### DevToolsdiff --git a/packages/playwright/src/skill/references/running-code.md b/packages/playwright/src/skill/references/running-code.mdindex 53fdcff76a..8e20ea6f50 100644--- a/packages/playwright/src/skill/references/running-code.md+++ b/packages/playwright/src/skill/references/running-code.md@@ -106,7 +106,7 @@ playwright-cli run-code "async page => {```bash# Work with iframeplaywright-cli run-code "async page => {- const frame = page.frameLocator('iframe#my-iframe');+ const frame = page.locator('iframe#my-iframe').contentFrame();await frame.locator('button').click();}"diff --git a/packages/playwright/src/skill/references/storage-state.md b/packages/playwright/src/skill/references/storage-state.mdindex 7cf83e8c4c..2c0ebca370 100644--- a/packages/playwright/src/skill/references/storage-state.md+++ b/packages/playwright/src/skill/references/storage-state.md@@ -58,248 +58,150 @@ The saved file contains:## Cookies-### Get All Cookies+### List All Cookies```bash-playwright-cli run-code "async page => {- const cookies = await page.context().cookies();- return cookies;-}"+playwright-cli cookie-list```-### Get Cookies for Specific URL+### Filter Cookies by Domain```bash-playwright-cli run-code "async page => {- const cookies = await page.context().cookies('https://example.com');- return cookies;-}"+playwright-cli cookie-list --domain=example.com```-### Add a Single Cookie+### Filter Cookies by Path```bash-playwright-cli run-code "async page => {- await page.context().addCookies([{- name: 'session',- value: 'abc123',- domain: 'example.com',- path: '/'- }]);-}"+playwright-cli cookie-list --path=/api```-### Add Multiple Cookies+### Get Specific Cookie```bash-playwright-cli run-code "async page => {- await page.context().addCookies([- {- name: 'session_id',- value: 'sess_abc123',- domain: 'example.com',- path: '/',- httpOnly: true,- secure: true- },- {- name: 'preferences',- value: JSON.stringify({ theme: 'dark', lang: 'en' }),- domain: 'example.com',- path: '/'- },- {- name: 'tracking_opt_out',- value: 'true',- domain: '.example.com',- path: '/'- }- ]);-}"+playwright-cli cookie-get session_id```-### Add Cookie with Expiration+### Set a Cookie```bash-playwright-cli run-code "async page => {- const oneWeekFromNow = Date.now() / 1000 + 7 * 24 * 60 * 60;- await page.context().addCookies([{- name: 'remember_me',- value: 'token123',- domain: 'example.com',- path: '/',- expires: oneWeekFromNow- }]);-}"-```+# Basic cookie+playwright-cli cookie-set session abc123-### Clear All Cookies+# Cookie with options+playwright-cli cookie-set session abc123 --domain=example.com --path=/ --httpOnly --secure --sameSite=Lax-```bash-playwright-cli run-code "async page => {- await page.context().clearCookies();-}"+# Cookie with expiration (Unix timestamp)+playwright-cli cookie-set remember_me token123 --expires=1735689600```-### Clear Cookies by Name+### Delete a Cookie```bash-playwright-cli run-code "async page => {- await page.context().clearCookies({ name: 'session_id' });-}"+playwright-cli cookie-delete session_id```-### Clear Cookies by Domain+### Clear All Cookies```bash-playwright-cli run-code "async page => {- await page.context().clearCookies({ domain: 'example.com' });-}"+playwright-cli cookie-clear```-### Clear Cookies by Path+### Advanced: Multiple Cookies or Custom Options-```bash-playwright-cli run-code "async page => {- await page.context().clearCookies({ path: '/api' });-}"-```--### Find Specific Cookie+For complex scenarios like adding multiple cookies at once, use `run-code`:```bashplaywright-cli run-code "async page => {- const cookies = await page.context().cookies();- const session = cookies.find(c => c.name === 'session_id');- return session ? session.value : null;+ await page.context().addCookies([+ { name: 'session_id', value: 'sess_abc123', domain: 'example.com', path: '/', httpOnly: true },+ { name: 'preferences', value: JSON.stringify({ theme: 'dark' }), domain: 'example.com', path: '/' }+ ]);}"```## Local Storage-### Get All localStorage+### List All localStorage Items```bash-playwright-cli run-code "async page => {- return await page.evaluate(() => {- const items = {};- for (let i = 0; i < localStorage.length; i++) {- const key = localStorage.key(i);- items[key] = localStorage.getItem(key);- }- return items;- });-}"+playwright-cli localstorage-list```### Get Single Value```bash-playwright-cli run-code "async page => {- return await page.evaluate(() => localStorage.getItem('token'));-}"-```--### Get and Parse JSON Value--```bash-playwright-cli run-code "async page => {- return await page.evaluate(() => {- const data = localStorage.getItem('user_settings');- return data ? JSON.parse(data) : null;- });-}"+playwright-cli localstorage-get token```### Set Value```bash-playwright-cli run-code "async page => {- await page.evaluate(() => localStorage.setItem('theme', 'dark'));-}"+playwright-cli localstorage-set theme dark```### Set JSON Value```bash-playwright-cli run-code "async page => {- await page.evaluate(() => {- localStorage.setItem('user_settings', JSON.stringify({- theme: 'dark',- language: 'en',- notifications: true- }));- });-}"+playwright-cli localstorage-set user_settings '{"theme":"dark","language":"en"}'```-### Set Multiple Values+### Delete Single Item```bash-playwright-cli run-code "async page => {- await page.evaluate(() => {- localStorage.setItem('token', 'jwt_abc123');- localStorage.setItem('user_id', '12345');- localStorage.setItem('expires_at', Date.now() + 3600000);- });-}"+playwright-cli localstorage-delete token```-### Remove Single Item+### Clear All localStorage```bash-playwright-cli run-code "async page => {- await page.evaluate(() => localStorage.removeItem('token'));-}"+playwright-cli localstorage-clear```-### Clear All localStorage+### Advanced: Multiple Operations++For complex scenarios like setting multiple values at once, use `run-code`:```bashplaywright-cli run-code "async page => {- await page.evaluate(() => localStorage.clear());+ await page.evaluate(() => {+ localStorage.setItem('token', 'jwt_abc123');+ localStorage.setItem('user_id', '12345');+ localStorage.setItem('expires_at', Date.now() + 3600000);+ });}"```## Session Storage-### Get All sessionStorage+### List All sessionStorage Items```bash-playwright-cli run-code "async page => {- return await page.evaluate(() => {- const items = {};- for (let i = 0; i < sessionStorage.length; i++) {- const key = sessionStorage.key(i);- items[key] = sessionStorage.getItem(key);- }- return items;- });-}"+playwright-cli sessionstorage-list```### Get Single Value```bash-playwright-cli run-code "async page => {- return await page.evaluate(() => sessionStorage.getItem('form_data'));-}"+playwright-cli sessionstorage-get form_data```### Set Value```bash-playwright-cli run-code "async page => {- await page.evaluate(() => sessionStorage.setItem('step', '3'));-}"+playwright-cli sessionstorage-set step 3+```++### Delete Single Item++```bash+playwright-cli sessionstorage-delete step```### Clear sessionStorage```bash-playwright-cli run-code "async page => {- await page.evaluate(() => sessionStorage.clear());-}"+playwright-cli sessionstorage-clear```## IndexedDBdiff --git a/tests/mcp/cli-cookies.spec.ts b/tests/mcp/cli-cookies.spec.tsnew file mode 100644index 0000000000..8abe37a927--- /dev/null+++ b/tests/mcp/cli-cookies.spec.ts@@ -0,0 +1,88 @@+/**+ * 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 { test, expect } from './cli-fixtures';++// Cookie tests++test('cookie-list shows no cookies when empty', async ({ cli, server, mcpBrowser }, testInfo) => {+ test.skip(mcpBrowser === 'msedge', 'Edge is leaking some internal cookies');+ const config = { capabilities: ['storage'] };+ await fs.promises.writeFile(testInfo.outputPath('playwright-cli.json'), JSON.stringify(config, null, 2));++ await cli('open', server.EMPTY_PAGE);+ const { output } = await cli('cookie-list');+ expect(output).toContain('No cookies found');+});++test('cookie-set and cookie-get', async ({ cli, server }, testInfo) => {+ const config = { capabilities: ['storage'] };+ await fs.promises.writeFile(testInfo.outputPath('playwright-cli.json'), JSON.stringify(config, null, 2));++ await cli('open', server.EMPTY_PAGE);++ // Set a cookie+ await cli('cookie-set', 'testCookie', 'testValue');++ // Get the cookie+ const { output: getOutput } = await cli('cookie-get', 'testCookie');+ expect(getOutput).toContain('testCookie=testValue');+});++test('cookie-list shows cookies', async ({ cli, server }, testInfo) => {+ const config = { capabilities: ['storage'] };+ await fs.promises.writeFile(testInfo.outputPath('playwright-cli.json'), JSON.stringify(config, null, 2));++ await cli('open', server.EMPTY_PAGE);+ await cli('cookie-set', 'cookie1', 'value1');+ await cli('cookie-set', 'cookie2', 'value2');++ const { output } = await cli('cookie-list');+ expect(output).toContain('cookie1=value1');+ expect(output).toContain('cookie2=value2');+});++test('cookie-delete removes cookie', async ({ cli, server }, testInfo) => {+ const config = { capabilities: ['storage'] };+ await fs.promises.writeFile(testInfo.outputPath('playwright-cli.json'), JSON.stringify(config, null, 2));++ await cli('open', server.EMPTY_PAGE);+ await cli('cookie-set', 'testCookie', 'testValue');++ // Delete the cookie+ await cli('cookie-delete', 'testCookie');++ // Verify it's gone+ const { output: getOutput } = await cli('cookie-get', 'testCookie');+ expect(getOutput).toContain('not found');+});++test('cookie-clear removes all cookies', async ({ cli, server }, testInfo) => {+ const config = { capabilities: ['storage'] };+ await fs.promises.writeFile(testInfo.outputPath('playwright-cli.json'), JSON.stringify(config, null, 2));++ await cli('open', server.EMPTY_PAGE);+ await cli('cookie-set', 'cookie1', 'value1');+ await cli('cookie-set', 'cookie2', 'value2');++ // Clear all cookies+ await cli('cookie-clear');++ // Verify they're gone+ const { output: listOutput } = await cli('cookie-list');+ expect(listOutput).toContain('No cookies found');+});diff --git a/tests/mcp/cli-webstorage.spec.ts b/tests/mcp/cli-webstorage.spec.tsnew file mode 100644index 0000000000..9bc8b93c5c--- /dev/null+++ b/tests/mcp/cli-webstorage.spec.ts@@ -0,0 +1,152 @@+/**+ * 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 { test, expect } from './cli-fixtures';++test('localstorage-list shows no items when empty', async ({ cli, server }, testInfo) => {+ const config = { capabilities: ['storage'] };+ await fs.promises.writeFile(testInfo.outputPath('playwright-cli.json'), JSON.stringify(config, null, 2));++ await cli('open', server.EMPTY_PAGE);+ const { output } = await cli('localstorage-list');+ expect(output).toContain('No localStorage items found');+});++test('localstorage-set and localstorage-get', async ({ cli, server }, testInfo) => {+ const config = { capabilities: ['storage'] };+ await fs.promises.writeFile(testInfo.outputPath('playwright-cli.json'), JSON.stringify(config, null, 2));++ await cli('open', server.EMPTY_PAGE);++ // Set an item+ await cli('localstorage-set', 'testKey', 'testValue');++ // Get the item+ const { output: getOutput } = await cli('localstorage-get', 'testKey');+ expect(getOutput).toContain('testKey=testValue');+});++test('localstorage-list shows items', async ({ cli, server }, testInfo) => {+ const config = { capabilities: ['storage'] };+ await fs.promises.writeFile(testInfo.outputPath('playwright-cli.json'), JSON.stringify(config, null, 2));++ await cli('open', server.EMPTY_PAGE);+ await cli('localstorage-set', 'key1', 'value1');+ await cli('localstorage-set', 'key2', 'value2');++ const { output } = await cli('localstorage-list');+ expect(output).toContain('key1=value1');+ expect(output).toContain('key2=value2');+});++test('localstorage-delete removes item', async ({ cli, server }, testInfo) => {+ const config = { capabilities: ['storage'] };+ await fs.promises.writeFile(testInfo.outputPath('playwright-cli.json'), JSON.stringify(config, null, 2));++ await cli('open', server.EMPTY_PAGE);+ await cli('localstorage-set', 'testKey', 'testValue');++ // Delete the item+ await cli('localstorage-delete', 'testKey');++ // Verify it's gone+ const { output: getOutput } = await cli('localstorage-get', 'testKey');+ expect(getOutput).toContain('not found');+});++test('localstorage-clear removes all items', async ({ cli, server }, testInfo) => {+ const config = { capabilities: ['storage'] };+ await fs.promises.writeFile(testInfo.outputPath('playwright-cli.json'), JSON.stringify(config, null, 2));++ await cli('open', server.EMPTY_PAGE);+ await cli('localstorage-set', 'key1', 'value1');+ await cli('localstorage-set', 'key2', 'value2');++ // Clear all items+ await cli('localstorage-clear');++ // Verify they're gone+ const { output: listOutput } = await cli('localstorage-list');+ expect(listOutput).toContain('No localStorage items found');+});++test('sessionstorage-list shows no items when empty', async ({ cli, server }, testInfo) => {+ const config = { capabilities: ['storage'] };+ await fs.promises.writeFile(testInfo.outputPath('playwright-cli.json'), JSON.stringify(config, null, 2));++ await cli('open', server.EMPTY_PAGE);+ const { output } = await cli('sessionstorage-list');+ expect(output).toContain('No sessionStorage items found');+});++test('sessionstorage-set and sessionstorage-get', async ({ cli, server }, testInfo) => {+ const config = { capabilities: ['storage'] };+ await fs.promises.writeFile(testInfo.outputPath('playwright-cli.json'), JSON.stringify(config, null, 2));++ await cli('open', server.EMPTY_PAGE);++ // Set an item+ await cli('sessionstorage-set', 'testKey', 'testValue');++ // Get the item+ const { output: getOutput } = await cli('sessionstorage-get', 'testKey');+ expect(getOutput).toContain('testKey=testValue');+});++test('sessionstorage-list shows items', async ({ cli, server }, testInfo) => {+ const config = { capabilities: ['storage'] };+ await fs.promises.writeFile(testInfo.outputPath('playwright-cli.json'), JSON.stringify(config, null, 2));++ await cli('open', server.EMPTY_PAGE);+ await cli('sessionstorage-set', 'key1', 'value1');+ await cli('sessionstorage-set', 'key2', 'value2');++ const { output } = await cli('sessionstorage-list');+ expect(output).toContain('key1=value1');+ expect(output).toContain('key2=value2');+});++test('sessionstorage-delete removes item', async ({ cli, server }, testInfo) => {+ const config = { capabilities: ['storage'] };+ await fs.promises.writeFile(testInfo.outputPath('playwright-cli.json'), JSON.stringify(config, null, 2));++ await cli('open', server.EMPTY_PAGE);+ await cli('sessionstorage-set', 'testKey', 'testValue');++ // Delete the item+ await cli('sessionstorage-delete', 'testKey');++ // Verify it's gone+ const { output: getOutput } = await cli('sessionstorage-get', 'testKey');+ expect(getOutput).toContain('not found');+});++test('sessionstorage-clear removes all items', async ({ cli, server }, testInfo) => {+ const config = { capabilities: ['storage'] };+ await fs.promises.writeFile(testInfo.outputPath('playwright-cli.json'), JSON.stringify(config, null, 2));++ await cli('open', server.EMPTY_PAGE);+ await cli('sessionstorage-set', 'key1', 'value1');+ await cli('sessionstorage-set', 'key2', 'value2');++ // Clear all items+ await cli('sessionstorage-clear');++ // Verify they're gone+ const { output: listOutput } = await cli('sessionstorage-list');+ expect(listOutput).toContain('No sessionStorage items found');+});diff --git a/tests/mcp/cookies.spec.ts b/tests/mcp/cookies.spec.tsnew file mode 100644index 0000000000..98b2c54503--- /dev/null+++ b/tests/mcp/cookies.spec.ts@@ -0,0 +1,336 @@+/**+ * 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 { test, expect } from './fixtures';++test('browser_cookie_list unavailable without storage capability', async ({ startClient, server }) => {+ const { client } = await startClient();+ await client.callTool({+ name: 'browser_navigate',+ arguments: { url: server.HELLO_WORLD },+ });++ expect(await client.callTool({+ name: 'browser_cookie_list',+ })).toHaveResponse({+ error: 'Tool "browser_cookie_list" not found',+ isError: true,+ });+});++test('browser_cookie_list shows no cookies when empty', async ({ startClient, server, mcpBrowser }) => {+ test.skip(mcpBrowser === 'msedge', 'Edge is leaking some internal cookies');+ const { client } = await startClient({+ config: { capabilities: ['storage'] },+ });++ await client.callTool({+ name: 'browser_navigate',+ arguments: { url: server.EMPTY_PAGE },+ });++ const result = await client.callTool({+ name: 'browser_cookie_list',+ arguments: {},+ });++ expect(result).toHaveResponse({+ result: 'No cookies found',+ });+});++test('browser_cookie_set and browser_cookie_get', async ({ startClient, server }) => {+ const { client } = await startClient({+ config: { capabilities: ['storage'] },+ });++ await client.callTool({+ name: 'browser_navigate',+ arguments: { url: server.EMPTY_PAGE },+ });++ // Set a cookie+ await client.callTool({+ name: 'browser_cookie_set',+ arguments: { name: 'testCookie', value: 'testValue' },+ });++ // Get the cookie+ const getResult = await client.callTool({+ name: 'browser_cookie_get',+ arguments: { name: 'testCookie' },+ });++ expect(getResult).toHaveResponse({+ result: expect.stringContaining('testCookie=testValue'),+ });+});++test('browser_cookie_list shows cookies', async ({ startClient, server }) => {+ const { client } = await startClient({+ config: { capabilities: ['storage'] },+ });++ await client.callTool({+ name: 'browser_navigate',+ arguments: { url: server.EMPTY_PAGE },+ });++ await client.callTool({+ name: 'browser_cookie_set',+ arguments: { name: 'cookie1', value: 'value1' },+ });++ await client.callTool({+ name: 'browser_cookie_set',+ arguments: { name: 'cookie2', value: 'value2' },+ });++ const result = await client.callTool({+ name: 'browser_cookie_list',+ arguments: {},+ });++ expect(result).toHaveResponse({+ result: expect.stringContaining('cookie1=value1'),+ });++ expect(result).toHaveResponse({+ result: expect.stringContaining('cookie2=value2'),+ });+});++test('browser_cookie_list filters by domain', async ({ startClient, server }) => {+ const { client } = await startClient({+ config: { capabilities: ['storage'] },+ });++ await client.callTool({+ name: 'browser_navigate',+ arguments: { url: server.EMPTY_PAGE },+ });++ await client.callTool({+ name: 'browser_cookie_set',+ arguments: { name: 'localCookie', value: 'localValue' },+ });++ const result = await client.callTool({+ name: 'browser_cookie_list',+ arguments: { domain: 'localhost' },+ });++ expect(result).toHaveResponse({+ result: expect.stringContaining('localCookie=localValue'),+ });++ const noResult = await client.callTool({+ name: 'browser_cookie_list',+ arguments: { domain: 'nonexistent.com' },+ });++ expect(noResult).toHaveResponse({+ result: 'No cookies found',+ });+});++test('browser_cookie_get returns not found for missing cookie', async ({ startClient, server }) => {+ const { client } = await startClient({+ config: { capabilities: ['storage'] },+ });++ await client.callTool({+ name: 'browser_navigate',+ arguments: { url: server.EMPTY_PAGE },+ });++ const result = await client.callTool({+ name: 'browser_cookie_get',+ arguments: { name: 'nonexistent' },+ });++ expect(result).toHaveResponse({+ result: expect.stringContaining('not found'),+ });+});++test('browser_cookie_set with all options', async ({ startClient, server, mcpBrowser }) => {+ const { client } = await startClient({+ config: { capabilities: ['storage'] },+ });++ await client.callTool({+ name: 'browser_navigate',+ arguments: { url: server.EMPTY_PAGE },+ });++ const futureTime = Math.floor(Date.now() / 1000) + 3600; // 1 hour from now++ await client.callTool({+ name: 'browser_cookie_set',+ arguments: {+ name: 'fullCookie',+ value: 'fullValue',+ path: '/test',+ expires: futureTime,+ httpOnly: true,+ secure: false,+ sameSite: 'Lax',+ },+ });++ // Verify the cookie with detailed info+ const getResult = await client.callTool({+ name: 'browser_cookie_get',+ arguments: { name: 'fullCookie' },+ });++ expect(getResult).toHaveResponse({+ result: expect.stringContaining('fullCookie=fullValue'),+ });++ expect(getResult).toHaveResponse({+ result: expect.stringContaining('httpOnly: true'),+ });++ const sameSite = process.platform === 'win32' && mcpBrowser === 'webkit' ? 'None' : 'Lax';+ expect(getResult).toHaveResponse({+ result: expect.stringContaining(`sameSite: ${sameSite}`),+ });+});++test('browser_cookie_delete removes cookie', async ({ startClient, server }) => {+ const { client } = await startClient({+ config: { capabilities: ['storage'] },+ });++ await client.callTool({+ name: 'browser_navigate',+ arguments: { url: server.EMPTY_PAGE },+ });++ await client.callTool({+ name: 'browser_cookie_set',+ arguments: { name: 'toDelete', value: 'deleteMe' },+ });++ // Verify it exists+ const beforeDelete = await client.callTool({+ name: 'browser_cookie_get',+ arguments: { name: 'toDelete' },+ });++ expect(beforeDelete).toHaveResponse({+ result: expect.stringContaining('toDelete=deleteMe'),+ });++ // Delete the cookie+ await client.callTool({+ name: 'browser_cookie_delete',+ arguments: { name: 'toDelete' },+ });++ // Verify it's gone+ const afterDelete = await client.callTool({+ name: 'browser_cookie_get',+ arguments: { name: 'toDelete' },+ });++ expect(afterDelete).toHaveResponse({+ result: expect.stringContaining('not found'),+ });+});++test('browser_cookie_delete for nonexistent cookie does not error', async ({ startClient, server }) => {+ const { client } = await startClient({+ config: { capabilities: ['storage'] },+ });++ await client.callTool({+ name: 'browser_navigate',+ arguments: { url: server.EMPTY_PAGE },+ });++ // Set a cookie to verify delete of nonexistent doesn't affect existing cookies+ await client.callTool({+ name: 'browser_cookie_set',+ arguments: { name: 'existing', value: 'value' },+ });++ // Deleting nonexistent cookie should not throw+ await client.callTool({+ name: 'browser_cookie_delete',+ arguments: { name: 'nonexistent' },+ });++ // Existing cookie should still be there+ const result = await client.callTool({+ name: 'browser_cookie_get',+ arguments: { name: 'existing' },+ });++ expect(result).toHaveResponse({+ result: expect.stringContaining('existing=value'),+ });+});++test('browser_cookie_clear removes all cookies', async ({ startClient, server }) => {+ const { client } = await startClient({+ config: { capabilities: ['storage'] },+ });++ await client.callTool({+ name: 'browser_navigate',+ arguments: { url: server.EMPTY_PAGE },+ });++ // Set multiple cookies+ await client.callTool({+ name: 'browser_cookie_set',+ arguments: { name: 'cookie1', value: 'value1' },+ });++ await client.callTool({+ name: 'browser_cookie_set',+ arguments: { name: 'cookie2', value: 'value2' },+ });++ // Verify they exist+ const beforeClear = await client.callTool({+ name: 'browser_cookie_list',+ arguments: {},+ });++ expect(beforeClear).toHaveResponse({+ result: expect.stringContaining('cookie1'),+ });++ // Clear all cookies+ await client.callTool({+ name: 'browser_cookie_clear',+ arguments: {},+ });++ // Verify they're all gone+ const afterClear = await client.callTool({+ name: 'browser_cookie_list',+ arguments: {},+ });++ expect(afterClear).toHaveResponse({+ result: 'No cookies found',+ });+});diff --git a/tests/mcp/webstorage.spec.ts b/tests/mcp/webstorage.spec.tsnew file mode 100644index 0000000000..b8eceb1cf9--- /dev/null+++ b/tests/mcp/webstorage.spec.ts@@ -0,0 +1,472 @@+/**+ * 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 { test, expect } from './fixtures';++test('browser_localstorage_list unavailable without storage capability', async ({ startClient, server }) => {+ const { client } = await startClient();+ await client.callTool({+ name: 'browser_navigate',+ arguments: { url: server.HELLO_WORLD },+ });++ expect(await client.callTool({+ name: 'browser_localstorage_list',+ })).toHaveResponse({+ error: 'Tool "browser_localstorage_list" not found',+ isError: true,+ });+});++test('browser_localstorage_list shows no items when empty', async ({ startClient, server }) => {+ const { client } = await startClient({+ config: { capabilities: ['storage'] },+ });++ await client.callTool({+ name: 'browser_navigate',+ arguments: { url: server.EMPTY_PAGE },+ });++ const result = await client.callTool({+ name: 'browser_localstorage_list',+ arguments: {},+ });++ expect(result).toHaveResponse({+ result: 'No localStorage items found',+ });+});++test('browser_localstorage_set and browser_localstorage_get', async ({ startClient, server }) => {+ const { client } = await startClient({+ config: { capabilities: ['storage'] },+ });++ await client.callTool({+ name: 'browser_navigate',+ arguments: { url: server.EMPTY_PAGE },+ });++ // Set an item+ await client.callTool({+ name: 'browser_localstorage_set',+ arguments: { key: 'testKey', value: 'testValue' },+ });++ // Get the item+ const getResult = await client.callTool({+ name: 'browser_localstorage_get',+ arguments: { key: 'testKey' },+ });++ expect(getResult).toHaveResponse({+ result: expect.stringContaining('testKey=testValue'),+ });+});++test('browser_localstorage_list shows items', async ({ startClient, server }) => {+ const { client } = await startClient({+ config: { capabilities: ['storage'] },+ });++ await client.callTool({+ name: 'browser_navigate',+ arguments: { url: server.EMPTY_PAGE },+ });++ await client.callTool({+ name: 'browser_localstorage_set',+ arguments: { key: 'key1', value: 'value1' },+ });++ await client.callTool({+ name: 'browser_localstorage_set',+ arguments: { key: 'key2', value: 'value2' },+ });++ const result = await client.callTool({+ name: 'browser_localstorage_list',+ arguments: {},+ });++ expect(result).toHaveResponse({+ result: expect.stringContaining('key1=value1'),+ });++ expect(result).toHaveResponse({+ result: expect.stringContaining('key2=value2'),+ });+});++test('browser_localstorage_get returns not found for missing key', async ({ startClient, server }) => {+ const { client } = await startClient({+ config: { capabilities: ['storage'] },+ });++ await client.callTool({+ name: 'browser_navigate',+ arguments: { url: server.EMPTY_PAGE },+ });++ const result = await client.callTool({+ name: 'browser_localstorage_get',+ arguments: { key: 'nonexistent' },+ });++ expect(result).toHaveResponse({+ result: expect.stringContaining('not found'),+ });+});++test('browser_localstorage_delete removes item', async ({ startClient, server }) => {+ const { client } = await startClient({+ config: { capabilities: ['storage'] },+ });++ await client.callTool({+ name: 'browser_navigate',+ arguments: { url: server.EMPTY_PAGE },+ });++ await client.callTool({+ name: 'browser_localstorage_set',+ arguments: { key: 'toDelete', value: 'deleteMe' },+ });++ // Verify it exists+ const beforeDelete = await client.callTool({+ name: 'browser_localstorage_get',+ arguments: { key: 'toDelete' },+ });++ expect(beforeDelete).toHaveResponse({+ result: expect.stringContaining('toDelete=deleteMe'),+ });++ // Delete the item+ await client.callTool({+ name: 'browser_localstorage_delete',+ arguments: { key: 'toDelete' },+ });++ // Verify it's gone+ const afterDelete = await client.callTool({+ name: 'browser_localstorage_get',+ arguments: { key: 'toDelete' },+ });++ expect(afterDelete).toHaveResponse({+ result: expect.stringContaining('not found'),+ });+});++test('browser_localstorage_clear removes all items', async ({ startClient, server }) => {+ const { client } = await startClient({+ config: { capabilities: ['storage'] },+ });++ await client.callTool({+ name: 'browser_navigate',+ arguments: { url: server.EMPTY_PAGE },+ });++ await client.callTool({+ name: 'browser_localstorage_set',+ arguments: { key: 'key1', value: 'value1' },+ });++ await client.callTool({+ name: 'browser_localstorage_set',+ arguments: { key: 'key2', value: 'value2' },+ });++ // Clear all items+ await client.callTool({+ name: 'browser_localstorage_clear',+ arguments: {},+ });++ // Verify they're all gone+ const afterClear = await client.callTool({+ name: 'browser_localstorage_list',+ arguments: {},+ });++ expect(afterClear).toHaveResponse({+ result: 'No localStorage items found',+ });+});++test('browser_sessionstorage_list unavailable without storage capability', async ({ startClient, server }) => {+ const { client } = await startClient();+ await client.callTool({+ name: 'browser_navigate',+ arguments: { url: server.HELLO_WORLD },+ });++ expect(await client.callTool({+ name: 'browser_sessionstorage_list',+ })).toHaveResponse({+ error: 'Tool "browser_sessionstorage_list" not found',+ isError: true,+ });+});++test('browser_sessionstorage_list shows no items when empty', async ({ startClient, server }) => {+ const { client } = await startClient({+ config: { capabilities: ['storage'] },+ });++ await client.callTool({+ name: 'browser_navigate',+ arguments: { url: server.EMPTY_PAGE },+ });++ const result = await client.callTool({+ name: 'browser_sessionstorage_list',+ arguments: {},+ });++ expect(result).toHaveResponse({+ result: 'No sessionStorage items found',+ });+});++test('browser_sessionstorage_set and browser_sessionstorage_get', async ({ startClient, server }) => {+ const { client } = await startClient({+ config: { capabilities: ['storage'] },+ });++ await client.callTool({+ name: 'browser_navigate',+ arguments: { url: server.EMPTY_PAGE },+ });++ // Set an item+ await client.callTool({+ name: 'browser_sessionstorage_set',+ arguments: { key: 'testKey', value: 'testValue' },+ });++ // Get the item+ const getResult = await client.callTool({+ name: 'browser_sessionstorage_get',+ arguments: { key: 'testKey' },+ });++ expect(getResult).toHaveResponse({+ result: expect.stringContaining('testKey=testValue'),+ });+});++test('browser_sessionstorage_list shows items', async ({ startClient, server }) => {+ const { client } = await startClient({+ config: { capabilities: ['storage'] },+ });++ await client.callTool({+ name: 'browser_navigate',+ arguments: { url: server.EMPTY_PAGE },+ });++ await client.callTool({+ name: 'browser_sessionstorage_set',+ arguments: { key: 'key1', value: 'value1' },+ });++ await client.callTool({+ name: 'browser_sessionstorage_set',+ arguments: { key: 'key2', value: 'value2' },+ });++ const result = await client.callTool({+ name: 'browser_sessionstorage_list',+ arguments: {},+ });++ expect(result).toHaveResponse({+ result: expect.stringContaining('key1=value1'),+ });++ expect(result).toHaveResponse({+ result: expect.stringContaining('key2=value2'),+ });+});++test('browser_sessionstorage_get returns not found for missing key', async ({ startClient, server }) => {+ const { client } = await startClient({+ config: { capabilities: ['storage'] },+ });++ await client.callTool({+ name: 'browser_navigate',+ arguments: { url: server.EMPTY_PAGE },+ });++ const result = await client.callTool({+ name: 'browser_sessionstorage_get',+ arguments: { key: 'nonexistent' },+ });++ expect(result).toHaveResponse({+ result: expect.stringContaining('not found'),+ });+});++test('browser_sessionstorage_delete removes item', async ({ startClient, server }) => {+ const { client } = await startClient({+ config: { capabilities: ['storage'] },+ });++ await client.callTool({+ name: 'browser_navigate',+ arguments: { url: server.EMPTY_PAGE },+ });++ await client.callTool({+ name: 'browser_sessionstorage_set',+ arguments: { key: 'toDelete', value: 'deleteMe' },+ });++ // Verify it exists+ const beforeDelete = await client.callTool({+ name: 'browser_sessionstorage_get',+ arguments: { key: 'toDelete' },+ });++ expect(beforeDelete).toHaveResponse({+ result: expect.stringContaining('toDelete=deleteMe'),+ });++ // Delete the item+ await client.callTool({+ name: 'browser_sessionstorage_delete',+ arguments: { key: 'toDelete' },+ });++ // Verify it's gone+ const afterDelete = await client.callTool({+ name: 'browser_sessionstorage_get',+ arguments: { key: 'toDelete' },+ });++ expect(afterDelete).toHaveResponse({+ result: expect.stringContaining('not found'),+ });+});++test('browser_sessionstorage_clear removes all items', async ({ startClient, server }) => {+ const { client } = await startClient({+ config: { capabilities: ['storage'] },+ });++ await client.callTool({+ name: 'browser_navigate',+ arguments: { url: server.EMPTY_PAGE },+ });++ await client.callTool({+ name: 'browser_sessionstorage_set',+ arguments: { key: 'key1', value: 'value1' },+ });++ await client.callTool({+ name: 'browser_sessionstorage_set',+ arguments: { key: 'key2', value: 'value2' },+ });++ // Clear all items+ await client.callTool({+ name: 'browser_sessionstorage_clear',+ arguments: {},+ });++ // Verify they're all gone+ const afterClear = await client.callTool({+ name: 'browser_sessionstorage_list',+ arguments: {},+ });++ expect(afterClear).toHaveResponse({+ result: 'No sessionStorage items found',+ });+});++test('localStorage and sessionStorage are isolated', async ({ startClient, server }) => {+ const { client } = await startClient({+ config: { capabilities: ['storage'] },+ });++ await client.callTool({+ name: 'browser_navigate',+ arguments: { url: server.EMPTY_PAGE },+ });++ // Set items in both storages+ await client.callTool({+ name: 'browser_localstorage_set',+ arguments: { key: 'sharedKey', value: 'localValue' },+ });++ await client.callTool({+ name: 'browser_sessionstorage_set',+ arguments: { key: 'sharedKey', value: 'sessionValue' },+ });++ // Verify they have different values+ const localResult = await client.callTool({+ name: 'browser_localstorage_get',+ arguments: { key: 'sharedKey' },+ });++ expect(localResult).toHaveResponse({+ result: expect.stringContaining('sharedKey=localValue'),+ });++ const sessionResult = await client.callTool({+ name: 'browser_sessionstorage_get',+ arguments: { key: 'sharedKey' },+ });++ expect(sessionResult).toHaveResponse({+ result: expect.stringContaining('sharedKey=sessionValue'),+ });++ // Clear localStorage and verify sessionStorage is unaffected+ await client.callTool({+ name: 'browser_localstorage_clear',+ arguments: {},+ });++ const afterClearLocal = await client.callTool({+ name: 'browser_localstorage_get',+ arguments: { key: 'sharedKey' },+ });++ expect(afterClearLocal).toHaveResponse({+ result: expect.stringContaining('not found'),+ });++ const sessionStillExists = await client.callTool({+ name: 'browser_sessionstorage_get',+ arguments: { key: 'sharedKey' },+ });++ expect(sessionStillExists).toHaveResponse({+ result: expect.stringContaining('sharedKey=sessionValue'),+ });+});