Skip to content

Playwright is a framework for Web Testing and Automation. It allows testing Chromium, Firefox and WebKit with a single API.

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.md
new file mode 100644
index 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 commit
diff --git a/.github/workflows/tests_mcp.yml b/.github/workflows/tests_mcp.yml
index 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/colors
FORCE_COLOR: 1
ELECTRON_SKIP_BINARY_DOWNLOAD: 1
- PWDEBUGIMPL: 1
DEBUG: pw:mcp:error
jobs:
diff --git a/packages/playwright/src/mcp/browser/tools.ts b/packages/playwright/src/mcp/browser/tools.ts
index 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.ts
new file mode 100644
index 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.ts
new file mode 100644
index 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.ts
index 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: () => ({}),
+});
+
// Export
const screenshot = declareCommand({
@@ -639,6 +813,21 @@ const commandsArray: AnyCommandSchema[] = [
// storage category
stateLoad,
stateSave,
+ cookieList,
+ cookieGet,
+ cookieSet,
+ cookieDelete,
+ cookieClear,
+ localStorageList,
+ localStorageGet,
+ localStorageSet,
+ localStorageDelete,
+ localStorageClear,
+ sessionStorageList,
+ sessionStorageGet,
+ sessionStorageSet,
+ sessionStorageDelete,
+ sessionStorageClear,
// config category
config,
diff --git a/packages/playwright/src/mcp/terminal/program.ts b/packages/playwright/src/mcp/terminal/program.ts
index 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.md
index 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 0
playwright-cli state-save
playwright-cli state-save auth.json
playwright-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
```
### DevTools
diff --git a/packages/playwright/src/skill/references/running-code.md b/packages/playwright/src/skill/references/running-code.md
index 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 iframe
playwright-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.md
index 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`:
```bash
playwright-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`:
```bash
playwright-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
```
## IndexedDB
diff --git a/tests/mcp/cli-cookies.spec.ts b/tests/mcp/cli-cookies.spec.ts
new file mode 100644
index 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.ts
new file mode 100644
index 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.ts
new file mode 100644
index 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.ts
new file mode 100644
index 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'),
+ });
+});