diff --git a/src/cli/browser/browser-cookie.ts b/src/cli/browser/browser-cookie.ts index 61d55698b29..94d05466180 100644 --- a/src/cli/browser/browser-cookie.ts +++ b/src/cli/browser/browser-cookie.ts @@ -89,6 +89,8 @@ export const BROWSER_COOKIE_HANDLERS: Record = { } Object.assign(params, await getBrowserCommandTarget(flags, cwd, client)) const result = await client.call('browser.cookie.delete', params) - printResult(result, json, () => `Cookie "${name}" deleted`) + printResult(result, json, (v) => + v.deleted === false ? `No cookie "${name}" found` : `Cookie "${name}" deleted` + ) } } diff --git a/src/main/browser/agent-browser/agent-browser-bridge.ts b/src/main/browser/agent-browser/agent-browser-bridge.ts index 521d9132ecd..2e05f46bf15 100644 --- a/src/main/browser/agent-browser/agent-browser-bridge.ts +++ b/src/main/browser/agent-browser/agent-browser-bridge.ts @@ -19,6 +19,7 @@ import { } from './protocol/agent-browser-passthrough-arguments' import { AgentBrowserBridgeInteractionCommands } from './commands/agent-browser-bridge-interaction-commands' import { sendGuestCdpCommand } from '../cdp/debugger/guest-cdp-command' +import { deleteCookieByName } from '../cookies/browser-cookie-delete-by-name' import { toBrowserConsoleResult, toBrowserNetworkLogResult, @@ -71,21 +72,20 @@ export class AgentBrowserBridge extends AgentBrowserBridgeInteractionCommands { } async cookieDelete( - name?: string, + name: string, domain?: string, - _url?: string, + url?: string, worktreeId?: string, browserPageId?: string ): Promise { - return this.enqueueTargetedCommand(worktreeId, browserPageId, async (sessionName) => { - const args = ['cookies', 'clear'] - if (name) { - args.push('--name', name) - } - if (domain) { - args.push('--domain', domain) - } - return (await this.execAgentBrowser(sessionName, args)) as BrowserCookieDeleteResult + return this.enqueueTargetedCommand(worktreeId, browserPageId, async (_sessionName, target) => { + const wc = this.requireTargetWebContents(target) + // agent-browser's `cookies clear` ignores filters and wipes the profile's whole cookie jar. + return deleteCookieByName((method, params) => sendGuestCdpCommand(wc, method, params), name, { + domain, + url, + pageUrl: wc.getURL() + }) }) } diff --git a/src/main/browser/agent-browser/commands/agent-browser-bridge-navigation.test.ts b/src/main/browser/agent-browser/commands/agent-browser-bridge-navigation.test.ts index 798045c7c83..d080e681601 100644 --- a/src/main/browser/agent-browser/commands/agent-browser-bridge-navigation.test.ts +++ b/src/main/browser/agent-browser/commands/agent-browser-bridge-navigation.test.ts @@ -63,7 +63,8 @@ import { mockBrowserManager, mockWebContents, overrideBridgeWebContentsLookup, - resetAgentBrowserBridgeMocks + resetAgentBrowserBridgeMocks, + succeedRecordingAgentBrowserSpawns } from '../testing/agent-browser-bridge-test-harness' overrideBridgeWebContentsLookup(AgentBrowserBridge.prototype, webContentsFromIdMock) @@ -106,4 +107,26 @@ describe('AgentBrowserBridge', () => { expect.objectContaining({ expression: 'sideEffect()' }) ) }) + + it('deletes the named cookie through the guest debugger instead of clearing the profile', async () => { + const spawns = succeedRecordingAgentBrowserSpawns(execFileMock, stdinWrites, { cleared: true }) + const wc = mockWebContents(100, 'https://www.example.com/app') + wc.debugger.sendCommand.mockImplementation(async (method) => + method === 'Network.getAllCookies' + ? { cookies: [{ name: 'sid', domain: '.example.com', path: '/' }] } + : {} + ) + webContentsFromIdMock.mockReturnValue(wc) + + await expect(bridge.cookieDelete('sid')).resolves.toEqual({ deleted: true }) + + expect(wc.debugger.sendCommand).toHaveBeenCalledWith('Network.deleteCookies', { + name: 'sid', + domain: '.example.com', + path: '/' + }) + expect(spawns.map(({ command }) => command)).not.toContainEqual( + expect.arrayContaining(['cookies', 'clear']) + ) + }) }) diff --git a/src/main/browser/cdp/commands/cdp-auxiliary-commands.ts b/src/main/browser/cdp/commands/cdp-auxiliary-commands.ts index 68ed3ff8ab2..3aea76a3fb0 100644 --- a/src/main/browser/cdp/commands/cdp-auxiliary-commands.ts +++ b/src/main/browser/cdp/commands/cdp-auxiliary-commands.ts @@ -16,6 +16,7 @@ import type { BrowserViewportResult } from '../../../../shared/browser/runtime/runtime-browser-contracts' import type { CdpCommandSender } from '../debugger/cdp-command-sender' +import { deleteCookieByName } from '../../cookies/browser-cookie-delete-by-name' type ActiveCdpContext = { guest: WebContents @@ -85,24 +86,9 @@ export class CdpAuxiliaryCommands { } cookieDelete(name: string, domain?: string, url?: string): Promise { - return this.host.run(async ({ sender }) => { - const params: Record = { name } - if (domain) { - params.domain = domain - } - if (url) { - params.url = url - } - if (!domain && !url) { - const { result } = (await sender('Runtime.evaluate', { - expression: 'location.href', - returnByValue: true - })) as { result: { value: string } } - params.url = result.value - } - await sender('Network.deleteCookies', params) - return { deleted: true } - }) + return this.host.run(({ guest, sender }) => + deleteCookieByName(sender, name, { domain, url, pageUrl: guest.getURL() }) + ) } setViewport( diff --git a/src/main/browser/cookies/browser-cdp-cookie.ts b/src/main/browser/cookies/browser-cdp-cookie.ts index b72c956c964..8e9d68d3271 100644 --- a/src/main/browser/cookies/browser-cdp-cookie.ts +++ b/src/main/browser/cookies/browser-cdp-cookie.ts @@ -17,3 +17,12 @@ export type CdpCookie = { partitionKey?: CdpCookiePartitionKey | null partitionKeyOpaque?: boolean } + +/** Reads the `cookies` array from a `Network.getAllCookies` reply. */ +export function cdpCookiesFromCommand(value: unknown): CdpCookie[] { + if (typeof value !== 'object' || value === null || !('cookies' in value)) { + return [] + } + const cookies = value.cookies + return Array.isArray(cookies) ? cookies : [] +} diff --git a/src/main/browser/cookies/browser-cookie-clear-store.ts b/src/main/browser/cookies/browser-cookie-clear-store.ts index 08f0a39e985..c5711147121 100644 --- a/src/main/browser/cookies/browser-cookie-clear-store.ts +++ b/src/main/browser/cookies/browser-cookie-clear-store.ts @@ -13,7 +13,7 @@ import type { } from './storage/cookie-store-contracts' import { restoreEveryCookieIdentity } from './browser-cookie-identity-restore' import { normalizeCookiePartitionSite } from './sources/browser-cookie-source-partition' -import type { CdpCookie } from './browser-cdp-cookie' +import { cdpCookiesFromCommand, type CdpCookie } from './browser-cdp-cookie' function cdpSameSite(sameSite: Cookie['sameSite']): 'Strict' | 'Lax' | 'None' | undefined { if (sameSite === 'strict') { @@ -152,14 +152,6 @@ export function cdpSetCookieParamsFromIdentity( } } -function cdpCookiesFromCommand(value: unknown): CdpCookie[] { - if (typeof value !== 'object' || value === null || !('cookies' in value)) { - return [] - } - const cookies = value.cookies - return Array.isArray(cookies) ? cookies : [] -} - function cdpSetCookieSucceeded(value: unknown): boolean { if (typeof value !== 'object' || value === null || !('success' in value)) { return true diff --git a/src/main/browser/cookies/browser-cookie-delete-by-name.test.ts b/src/main/browser/cookies/browser-cookie-delete-by-name.test.ts new file mode 100644 index 00000000000..46034f40fc3 --- /dev/null +++ b/src/main/browser/cookies/browser-cookie-delete-by-name.test.ts @@ -0,0 +1,99 @@ +import { describe, expect, it } from 'vitest' +import { deleteCookieByName } from './browser-cookie-delete-by-name' + +const partitionKey = { topLevelSite: 'https://example.org', hasCrossSiteAncestor: true } +const COOKIES = [ + { name: 'sid', domain: '.example.com', path: '/' }, + { name: 'sid', domain: 'example.com', path: '/account' }, + { name: 'sid', domain: 'example.com', path: '/', partitionKey }, + { name: 'sid', domain: 'www.example.com', path: '/' }, + { name: 'sid', domain: 'example.net', path: '/' }, + { name: 'sid', domain: 'example.com', path: '/', partitionKeyOpaque: true }, + { name: 'keep', domain: '.example.com', path: '/' } +] + +async function deleteSid(target: Parameters[2]) { + const deletes: Record[] = [] + const result = await deleteCookieByName( + async (method, params) => { + if (method === 'Network.getAllCookies') { + return { cookies: COOKIES } + } + deletes.push({ method, ...params }) + return {} + }, + 'sid', + target + ) + return { result, deletes } +} + +describe('deleteCookieByName', () => { + it('deletes host-only and dot-prefixed cookies on the given domain', async () => { + const { result, deletes } = await deleteSid({ + domain: '.Example.COM', + pageUrl: 'https://ignored.test/' + }) + + expect(result).toEqual({ deleted: true }) + expect(deletes).toEqual([ + { method: 'Network.deleteCookies', name: 'sid', domain: '.example.com', path: '/' }, + { method: 'Network.deleteCookies', name: 'sid', domain: 'example.com', path: '/account' }, + { + method: 'Network.deleteCookies', + name: 'sid', + domain: 'example.com', + path: '/', + partitionKey + } + ]) + }) + + it('deletes cookies the URL host would receive, including parent-domain cookies', async () => { + const { deletes } = await deleteSid({ + url: 'https://www.example.com/app', + pageUrl: 'https://ignored.test/' + }) + + expect(deletes.map(({ domain }) => domain)).toEqual(['.example.com', 'www.example.com']) + }) + + it('reports nothing deleted when no cookie matches', async () => { + await expect( + deleteSid({ domain: 'example.org', pageUrl: 'https://ignored.test/' }) + ).resolves.toEqual({ + result: { deleted: false }, + deletes: [] + }) + }) + + it('rejects a domain or URL it cannot match cookies against', async () => { + await expect( + deleteSid({ domain: 'localhost:3000', pageUrl: 'https://ignored.test/' }) + ).rejects.toMatchObject({ + code: 'invalid_argument' + }) + await expect( + deleteSid({ url: 'example.com', pageUrl: 'https://ignored.test/' }) + ).rejects.toMatchObject({ + code: 'invalid_argument' + }) + }) + + it('falls back to the tab URL and asks for --domain or --url when it has no cookie host', async () => { + const { deletes } = await deleteSid({ pageUrl: 'https://www.example.com/app' }) + expect(deletes.map(({ domain }) => domain)).toEqual(['.example.com', 'www.example.com']) + + for (const pageUrl of [ + 'about:blank', + 'file:///tmp/a.html', + 'data:text/html,hi', + 'chrome-error://chromewebdata/' + ]) { + await expect(deleteSid({ pageUrl })).rejects.toMatchObject({ + code: 'invalid_argument', + message: expect.stringContaining('pass --domain or --url') + }) + } + }) +}) diff --git a/src/main/browser/cookies/browser-cookie-delete-by-name.ts b/src/main/browser/cookies/browser-cookie-delete-by-name.ts new file mode 100644 index 00000000000..8fdb422f2cd --- /dev/null +++ b/src/main/browser/cookies/browser-cookie-delete-by-name.ts @@ -0,0 +1,72 @@ +import type { BrowserCookieDeleteResult } from '../../../shared/browser/runtime/runtime-browser-contracts' +import { BrowserError } from '../browser-error' +import type { CdpCommandSender } from '../cdp/debugger/cdp-command-sender' +import { cdpCookiesFromCommand } from './browser-cdp-cookie' +import { normalizeCookieDomain } from './policy/cookie-domain' + +type CookieDeleteTarget = { + domain?: string + url?: string + /** The tab's URL, used when neither `domain` nor `url` is given. */ + pageUrl: string +} + +function cookieDeleteHost({ domain, url, pageUrl }: CookieDeleteTarget): string { + if (domain) { + const host = normalizeCookieDomain(domain) + if (!host) { + throw new BrowserError('invalid_argument', `Invalid cookie domain "${domain}"`) + } + return host + } + if (url) { + const host = URL.parse(url)?.hostname + if (!host) { + throw new BrowserError('invalid_argument', `Invalid cookie URL "${url}"`) + } + return host + } + const page = URL.parse(pageUrl) + if (!page?.hostname || (page.protocol !== 'http:' && page.protocol !== 'https:')) { + throw new BrowserError( + 'invalid_argument', + `The tab is on "${pageUrl}", which has no cookie domain; pass --domain or --url` + ) + } + return page.hostname +} + +/** + * Deletes cookies named `name` stored on `domain` (host-only or dot-prefixed), or else every cookie + * of that name the `url` (or tab) host would receive, at any path. Network.deleteCookies alone + * matches only the exact stored domain, which would leave `Domain=`-scoped cookies (stored as + * `.example.com`). + */ +export async function deleteCookieByName( + sender: CdpCommandSender, + name: string, + target: CookieDeleteTarget +): Promise { + const host = cookieDeleteHost(target) + const matches = cdpCookiesFromCommand(await sender('Network.getAllCookies')).filter( + ({ name: cookieName, domain: cookieDomain = '', partitionKeyOpaque }) => + cookieName === name && + // Opaque partition keys cannot be passed back to Network.deleteCookies. + !partitionKeyOpaque && + (cookieDomain === host || + cookieDomain === `.${host}` || + (!target.domain && cookieDomain.startsWith('.') && host.endsWith(cookieDomain))) + ) + await Promise.all( + matches.map((cookie) => + sender('Network.deleteCookies', { + name, + domain: cookie.domain, + path: cookie.path, + // Partitioned (CHIPS) cookies are only deleted when their partition key is passed back. + ...(cookie.partitionKey ? { partitionKey: cookie.partitionKey } : {}) + }) + ) + ) + return { deleted: matches.length > 0 } +} diff --git a/src/main/orcad/browser-providers/chromium/external-chromium-command-arguments.test.ts b/src/main/orcad/browser-providers/chromium/external-chromium-command-arguments.test.ts new file mode 100644 index 00000000000..2150cb4f94d --- /dev/null +++ b/src/main/orcad/browser-providers/chromium/external-chromium-command-arguments.test.ts @@ -0,0 +1,8 @@ +import { describe, expect, it } from 'vitest' +import { externalChromiumCommandArguments } from './external-chromium-command-arguments' + +describe('externalChromiumCommandArguments', () => { + it('leaves cookie delete unmapped because agent-browser can only clear the whole jar', () => { + expect(externalChromiumCommandArguments('browserCookieDelete', { name: 'sid' })).toBeNull() + }) +}) diff --git a/src/main/orcad/browser-providers/chromium/external-chromium-command-arguments.ts b/src/main/orcad/browser-providers/chromium/external-chromium-command-arguments.ts index 1fcdad2e183..2aa8c1d8096 100644 --- a/src/main/orcad/browser-providers/chromium/external-chromium-command-arguments.ts +++ b/src/main/orcad/browser-providers/chromium/external-chromium-command-arguments.ts @@ -41,16 +41,6 @@ function cookieSetArguments(params: Record): string[] { } return args } -function cookieDeleteArguments(params: Record): string[] { - const args = ['cookies', 'clear'] - if (params.name) { - args.push('--name', String(params.name)) - } - if (params.domain) { - args.push('--domain', String(params.domain)) - } - return args -} export function externalChromiumCommandArguments( method: string, @@ -139,8 +129,6 @@ export function externalChromiumCommandArguments( return ['highlight', text('selector')] case 'browserCookieGet': return ['cookies', 'get'] - case 'browserCookieDelete': - return cookieDeleteArguments(params) case 'browserSetGeolocation': return ['set', 'geo', text('latitude'), text('longitude')] case 'browserInterceptDisable':