Skip to content

Chrome DevTools for coding agents

feat: implement extension service worker logs (#1915)

Nicholas Roscino29e389848fd0
diff --git a/docs/tool-reference.md b/docs/tool-reference.md
index 91380a00..f2a002f5 100644
--- a/docs/tool-reference.md
+++ b/docs/tool-reference.md
@@ -394,6 +394,7 @@ so returned values have to be JSON-serializable.
- **includePreservedMessages** (boolean) _(optional)_: Set to true to return the preserved messages over the last 3 navigations.
- **pageIdx** (integer) _(optional)_: Page number to return (0-based). When omitted, returns the first page.
- **pageSize** (integer) _(optional)_: Maximum number of messages to return. When omitted, returns all messages.
+- **serviceWorkerId** (string) _(optional)_: Filter messages to only return messages of the specified service worker.
- **types** (array) _(optional)_: Filter messages to only return messages of the specified resource types. When omitted or empty, returns all messages.
---
diff --git a/src/McpContext.ts b/src/McpContext.ts
index 4346070d..876dc832 100644
--- a/src/McpContext.ts
+++ b/src/McpContext.ts
@@ -21,6 +21,7 @@ import {
type ListenerMap,
type UncaughtError,
} from './PageCollector.js';
+import {ServiceWorkerConsoleCollector} from './ServiceWorkerCollector.js';
import {
Locator,
PredefinedNetworkConditions,
@@ -84,6 +85,7 @@ export class McpContext implements Context {
#networkCollector: NetworkCollector;
#consoleCollector: ConsoleCollector;
#devtoolsUniverseManager: UniverseManager;
+ #serviceWorkerConsoleCollector: ServiceWorkerConsoleCollector;
#isRunningTrace = false;
#screenRecorderData: {recorder: ScreenRecorder; filePath: string} | null =
@@ -128,21 +130,26 @@ export class McpContext implements Context {
},
} as ListenerMap;
});
+ this.#serviceWorkerConsoleCollector = new ServiceWorkerConsoleCollector(
+ this.browser,
+ );
this.#devtoolsUniverseManager = new UniverseManager(this.browser);
}
async #init() {
const pages = await this.createPagesSnapshot();
- await this.createExtensionServiceWorkersSnapshot();
+ const workers = await this.createExtensionServiceWorkersSnapshot();
await this.#networkCollector.init(pages);
await this.#consoleCollector.init(pages);
await this.#devtoolsUniverseManager.init(pages);
+ await this.#serviceWorkerConsoleCollector.init(workers);
}
dispose() {
this.#networkCollector.dispose();
this.#consoleCollector.dispose();
this.#devtoolsUniverseManager.dispose();
+ this.#serviceWorkerConsoleCollector.dispose();
for (const mcpPage of this.#mcpPages.values()) {
mcpPage.dispose();
}
@@ -590,6 +597,12 @@ export class McpContext implements Context {
return this.#extensionServiceWorkers;
}
+ getServiceWorkerConsoleData(
+ extensionId: string,
+ ): Array<ConsoleMessage | UncaughtError> {
+ return this.#serviceWorkerConsoleCollector.getData(extensionId);
+ }
+
async createPagesSnapshot(): Promise<Page[]> {
const {pages: allPages, isolatedContextNames} = await this.#getAllPages();
diff --git a/src/McpResponse.ts b/src/McpResponse.ts
index 9dfea8be..7da6b58d 100644
--- a/src/McpResponse.ts
+++ b/src/McpResponse.ts
@@ -232,6 +232,7 @@ export class McpResponse implements Response {
pagination?: PaginationOptions;
types?: string[];
includePreservedMessages?: boolean;
+ serviceWorkerId?: string;
};
#listExtensions?: boolean;
#listThirdPartyDeveloperTools?: boolean;
@@ -328,6 +329,7 @@ export class McpResponse implements Response {
options?: PaginationOptions & {
types?: string[];
includePreservedMessages?: boolean;
+ serviceWorkerId?: string;
},
): void {
if (!value) {
@@ -346,6 +348,7 @@ export class McpResponse implements Response {
: undefined,
types: options?.types,
includePreservedMessages: options?.includePreservedMessages,
+ serviceWorkerId: options?.serviceWorkerId,
};
}
@@ -620,14 +623,23 @@ export class McpResponse implements Response {
let consoleMessages: Array<ConsoleFormatter | IssueFormatter> | undefined;
if (this.#consoleDataOptions?.include) {
- if (!this.#page) {
- throw new Error(`Response must have an McpPage`);
+ let messages;
+ let page: McpPage | undefined;
+
+ if (this.#consoleDataOptions.serviceWorkerId) {
+ messages = context.getServiceWorkerConsoleData(
+ this.#consoleDataOptions.serviceWorkerId,
+ );
+ } else {
+ page = this.#page;
+ if (!page) {
+ throw new Error(`Response must have an McpPage`);
+ }
+ messages = context.getConsoleData(
+ page,
+ this.#consoleDataOptions.includePreservedMessages,
+ );
}
- const page = this.#page;
- let messages = context.getConsoleData(
- this.#page,
- this.#consoleDataOptions.includePreservedMessages,
- );
if (this.#consoleDataOptions.types?.length) {
const normalizedTypes = new Set(this.#consoleDataOptions.types);
@@ -650,7 +662,9 @@ export class McpResponse implements Response {
context.getConsoleMessageStableId(item);
if ('args' in item || item instanceof UncaughtError) {
const consoleMessage = item as ConsoleMessage | UncaughtError;
- const devTools = context.getDevToolsUniverse(page);
+ const devTools = page
+ ? context.getDevToolsUniverse(page)
+ : null;
return await ConsoleFormatter.from(consoleMessage, {
id: consoleMessageStableId,
fetchDetailedData: false,
diff --git a/src/PageCollector.ts b/src/PageCollector.ts
index e54ca70d..bfed5c15 100644
--- a/src/PageCollector.ts
+++ b/src/PageCollector.ts
@@ -194,11 +194,11 @@ export class PageCollector<T> {
const item = this.find(page, item => item[stableIdSymbol] === stableId);
- if (item) {
- return item;
+ if (!item) {
+ throw new Error('Request not found for selected page');
}
- throw new Error('Request not found for selected page');
+ return item;
}
find(
diff --git a/src/ServiceWorkerCollector.ts b/src/ServiceWorkerCollector.ts
new file mode 100644
index 00000000..562ffeb3
--- /dev/null
+++ b/src/ServiceWorkerCollector.ts
@@ -0,0 +1,227 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import {UncaughtError} from './PageCollector.js';
+import type {
+ ConsoleMessage,
+ WebWorker,
+ Target,
+ CDPSession,
+ Protocol,
+ Browser,
+} from './third_party/index.js';
+import type {ExtensionServiceWorker} from './types.js';
+import type {WithSymbolId} from './utils/id.js';
+import {createIdGenerator, stableIdSymbol} from './utils/id.js';
+
+const CHROME_EXTENSION_PREFIX = 'chrome-extension://';
+
+export class ServiceWorkerSubscriber {
+ #target: Target;
+ #callback: (item: ConsoleMessage | UncaughtError) => void;
+ #session?: CDPSession;
+ #worker?: WebWorker;
+
+ constructor(
+ target: Target,
+ callback: (item: ConsoleMessage | UncaughtError) => void,
+ ) {
+ this.#target = target;
+ this.#callback = callback;
+ }
+
+ async subscribe() {
+ this.#session = await this.#target.createCDPSession();
+ await this.#session.send('Runtime.enable');
+ this.#session.on('Runtime.exceptionThrown', this.#onExceptionThrown);
+
+ this.#worker = (await this.#target.worker()) ?? undefined;
+ if (this.#worker) {
+ this.#worker.on('console', this.#onConsole);
+ }
+ }
+
+ async unsubscribe() {
+ if (this.#worker) {
+ this.#worker.off('console', this.#onConsole);
+ }
+ await this.#session?.detach();
+ }
+
+ #onConsole = (message: ConsoleMessage) => {
+ this.#callback(message);
+ };
+
+ #onExceptionThrown = (event: Protocol.Runtime.ExceptionThrownEvent) => {
+ const url = this.#target.url();
+
+ const extensionId = extractExtensionId(url);
+
+ if (extensionId) {
+ this.#callback(new UncaughtError(event.exceptionDetails, extensionId));
+ }
+ };
+}
+
+export class ServiceWorkerConsoleCollector {
+ #storage = new Map<
+ string,
+ Array<WithSymbolId<ConsoleMessage | UncaughtError>>
+ >();
+ #maxLogs: number;
+ #browser?: Browser;
+ #serviceWorkerSubscribers = new Map<Target, ServiceWorkerSubscriber>();
+ #idGenerator = createIdGenerator();
+
+ constructor(browser?: Browser, maxLogs = 1000) {
+ this.#browser = browser;
+ this.#maxLogs = maxLogs;
+ }
+
+ async init(workers: ExtensionServiceWorker[]) {
+ if (!this.#browser) {
+ return;
+ }
+ this.#browser.on('targetcreated', this.#onTargetCreated);
+ this.#browser.on('targetdestroyed', this.#onTargetDestroyed);
+
+ for (const worker of workers) {
+ void this.#onTargetCreated(worker.target);
+ }
+ }
+
+ dispose() {
+ if (!this.#browser) {
+ return;
+ }
+ this.#browser.off('targetcreated', this.#onTargetCreated);
+ this.#browser.off('targetdestroyed', this.#onTargetDestroyed);
+ for (const subscriber of this.#serviceWorkerSubscribers.values()) {
+ subscriber.unsubscribe().catch(err => {
+ if (
+ err instanceof Error &&
+ !err.message.includes('Target closed') &&
+ !err.message.includes('Session closed')
+ ) {
+ // Swallow error as we are tearing down the system
+ }
+ });
+ }
+ this.#serviceWorkerSubscribers.clear();
+ }
+
+ #onTargetCreated = async (target: Target) => {
+ if (this.#serviceWorkerSubscribers.has(target)) {
+ return;
+ }
+ const origin = target.url();
+ if (target.type() === 'service_worker' && isExtensionOrigin(origin)) {
+ const extensionId = extractExtensionId(origin);
+
+ if (!extensionId) {
+ return;
+ }
+
+ const subscriber = new ServiceWorkerSubscriber(target, item => {
+ this.addLog(extensionId, item);
+ });
+ try {
+ await subscriber.subscribe();
+ } catch (err) {
+ if (
+ err instanceof Error &&
+ !err.message.includes('Target closed') &&
+ !err.message.includes('Session closed')
+ ) {
+ throw err;
+ }
+ }
+ this.#serviceWorkerSubscribers.set(target, subscriber);
+ }
+ };
+
+ #onTargetDestroyed = async (target: Target) => {
+ const subscriber = this.#serviceWorkerSubscribers.get(target);
+ if (subscriber) {
+ try {
+ await subscriber.unsubscribe();
+ } catch (err) {
+ if (
+ err instanceof Error &&
+ !err.message.includes('Target closed') &&
+ !err.message.includes('Session closed')
+ ) {
+ throw err;
+ }
+ }
+ this.#serviceWorkerSubscribers.delete(target);
+ }
+ };
+
+ addLog(extensionId: string, log: ConsoleMessage | UncaughtError) {
+ const logs = this.#storage.get(extensionId) ?? [];
+ const withId = log as WithSymbolId<ConsoleMessage | UncaughtError>;
+ withId[stableIdSymbol] = this.#idGenerator();
+ logs.push(withId);
+ if (logs.length > this.#maxLogs) {
+ logs.shift();
+ }
+ this.#storage.set(extensionId, logs);
+ }
+
+ getData(
+ extensionId: string,
+ ): Array<WithSymbolId<ConsoleMessage | UncaughtError>> {
+ return this.#storage.get(extensionId) ?? [];
+ }
+
+ getById(
+ extensionId: string,
+ stableId: number,
+ ): WithSymbolId<ConsoleMessage | UncaughtError> {
+ const logs = this.#storage.get(extensionId);
+ if (!logs) {
+ throw new Error('No logs found for selected extension');
+ }
+ const item = logs.find(item => item[stableIdSymbol] === stableId);
+ if (item) {
+ return item;
+ }
+ throw new Error('Log not found for selected extension');
+ }
+
+ find(
+ extensionId: string,
+ filter: (item: WithSymbolId<ConsoleMessage | UncaughtError>) => boolean,
+ ): WithSymbolId<ConsoleMessage | UncaughtError> | undefined {
+ const logs = this.#storage.get(extensionId);
+ if (!logs) {
+ return;
+ }
+ return logs.find(filter);
+ }
+
+ clearLogs(extensionId: string) {
+ this.#storage.delete(extensionId);
+ }
+}
+
+function extractExtensionId(origin: string): string | null {
+ if (!origin || !isExtensionOrigin(origin)) {
+ return null;
+ }
+
+ const pathPart = origin.substring(CHROME_EXTENSION_PREFIX.length);
+ const slashIndex = pathPart.indexOf('/');
+
+ // if there's no / it means that pathPart is now the extensionId, otherwise
+ // we take everything until the first /
+ return slashIndex === -1 ? pathPart : pathPart.substring(0, slashIndex);
+}
+
+function isExtensionOrigin(origin: string) {
+ return origin.startsWith(CHROME_EXTENSION_PREFIX);
+}
diff --git a/src/bin/chrome-devtools-cli-options.ts b/src/bin/chrome-devtools-cli-options.ts
index 235c02b3..b3e3f8e0 100644
--- a/src/bin/chrome-devtools-cli-options.ts
+++ b/src/bin/chrome-devtools-cli-options.ts
@@ -555,6 +555,13 @@ export const commands: Commands = {
required: false,
default: false,
},
+ serviceWorkerId: {
+ name: 'serviceWorkerId',
+ type: 'string',
+ description:
+ 'Filter messages to only return messages of the specified service worker.',
+ required: false,
+ },
},
},
list_extensions: {
diff --git a/src/telemetry/tool_call_metrics.json b/src/telemetry/tool_call_metrics.json
index 90a99753..b26445d6 100644
--- a/src/telemetry/tool_call_metrics.json
+++ b/src/telemetry/tool_call_metrics.json
@@ -254,6 +254,10 @@
{
"name": "include_preserved_messages",
"argType": "boolean"
+ },
+ {
+ "name": "service_worker_id_length",
+ "argType": "number"
}
]
},
diff --git a/src/third_party/index.ts b/src/third_party/index.ts
index 7cf50217..b7ffb657 100644
--- a/src/third_party/index.ts
+++ b/src/third_party/index.ts
@@ -47,7 +47,10 @@ export {default as puppeteer} from 'puppeteer-core';
export type * from 'puppeteer-core';
export {PipeTransport} from 'puppeteer-core/internal/node/PipeTransport.js';
export type {CdpPage} from 'puppeteer-core/internal/cdp/Page.js';
+export type {CdpWebWorker} from 'puppeteer-core/internal/cdp/WebWorker.js';
+export type {Realm} from 'puppeteer-core/internal/api/Realm.js';
export type {JSONSchema7, JSONSchema7Definition} from 'json-schema';
+
export {
resolveDefaultUserDataDir,
detectBrowserPlatform,
diff --git a/src/tools/ToolDefinition.ts b/src/tools/ToolDefinition.ts
index f2db6ca1..ad9eb300 100644
--- a/src/tools/ToolDefinition.ts
+++ b/src/tools/ToolDefinition.ts
@@ -130,6 +130,7 @@ export interface Response {
options?: PaginationOptions & {
types?: string[];
includePreservedMessages?: boolean;
+ serviceWorkerId?: string;
},
): void;
includeSnapshot(params?: SnapshotParams): void;
diff --git a/src/tools/console.ts b/src/tools/console.ts
index 421dccbf..8f2be8e0 100644
--- a/src/tools/console.ts
+++ b/src/tools/console.ts
@@ -77,6 +77,12 @@ export const listConsoleMessages = definePageTool(cliArgs => {
.describe(
'Set to true to return the preserved messages over the last 3 navigations.',
),
+ serviceWorkerId: zod
+ .string()
+ .optional()
+ .describe(
+ 'Filter messages to only return messages of the specified service worker.',
+ ),
},
blockedByDialog: false,
verifyFilesSchema: [],
@@ -86,6 +92,7 @@ export const listConsoleMessages = definePageTool(cliArgs => {
pageIdx: request.params.pageIdx,
types: request.params.types,
includePreservedMessages: request.params.includePreservedMessages,
+ serviceWorkerId: request.params.serviceWorkerId,
});
},
};
diff --git a/tests/ServiceWorkerCollector.test.ts b/tests/ServiceWorkerCollector.test.ts
new file mode 100644
index 00000000..2417e7a6
--- /dev/null
+++ b/tests/ServiceWorkerCollector.test.ts
@@ -0,0 +1,75 @@
+/**
+ * @license
+ * Copyright 2026 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import assert from 'node:assert';
+import {describe, it} from 'node:test';
+
+import {UncaughtError} from '../src/PageCollector.js';
+import {ServiceWorkerConsoleCollector} from '../src/ServiceWorkerCollector.js';
+import type {Protocol} from '../src/third_party/index.js';
+import {stableIdSymbol} from '../src/utils/id.js';
+
+describe('ServiceWorkerConsoleCollector', () => {
+ it('limits logs to 1000 per extension', () => {
+ const collector = new ServiceWorkerConsoleCollector(undefined, 10);
+ const extensionId = 'test-extension';
+
+ const mockDetails: Protocol.Runtime.ExceptionDetails = {
+ exceptionId: 1,
+ text: 'Error',
+ lineNumber: 1,
+ columnNumber: 1,
+ };
+
+ for (let i = 0; i < 15; i++) {
+ const error = new UncaughtError(
+ {...mockDetails, exceptionId: i},
+ extensionId,
+ );
+ collector.addLog(extensionId, error);
+ }
+
+ const logs = collector.getData(extensionId);
+ assert.strictEqual(logs.length, 10, 'Should limit logs to 10');
+
+ const firstLog = logs[0] as UncaughtError;
+ assert.strictEqual(
+ firstLog.details.exceptionId,
+ 5,
+ 'Oldest log should be Log 5',
+ );
+
+ const lastLog = logs[logs.length - 1] as UncaughtError;
+ assert.strictEqual(
+ lastLog.details.exceptionId,
+ 14,
+ 'Last log should be Log 14',
+ );
+
+ const data = collector.getData(extensionId);
+ assert.strictEqual(data.length, 10, 'getData should return limited logs');
+
+ const logToFind = data[0];
+ const logId = logToFind[stableIdSymbol];
+ assert.ok(logId, 'Log should have a stable ID');
+
+ const foundLog = collector.getById(extensionId, logId);
+ assert.strictEqual(
+ foundLog,
+ logToFind,
+ 'getById should return correct log',
+ );
+
+ const foundViaFind = collector.find(extensionId, item => {
+ return item[stableIdSymbol] === logId;
+ });
+ assert.strictEqual(
+ foundViaFind,
+ logToFind,
+ 'find should return correct log',
+ );
+ });
+});
diff --git a/tests/tools/console.test.js.snapshot b/tests/tools/console.test.js.snapshot
index 68ee7256..4e5d8d95 100644
--- a/tests/tools/console.test.js.snapshot
+++ b/tests/tools/console.test.js.snapshot
@@ -1,3 +1,11 @@
+exports[`console > captures logs and errors from extension service worker 1`] = `
+## Console messages
+Showing 1-3 of 3 (Page 1 of 1).
+msgid=1 [log] Service Worker starting... (1 args)
+msgid=2 [warn] This is a warning from Service Worker (1 args)
+msgid=3 [error] Uncaught Error: Intentional error from Service Worker (0 args)
+`;
+
exports[`console > get_console_message > applies source maps to stack traces of Error object (with cause) console.log arguments 1`] = `
ID: 1
Message: log> foo failed Error: bar failed
diff --git a/tests/tools/console.test.ts b/tests/tools/console.test.ts
index b68e6160..7ae59f24 100644
--- a/tests/tools/console.test.ts
+++ b/tests/tools/console.test.ts
@@ -5,6 +5,7 @@
*/
import assert from 'node:assert';
+import path from 'node:path';
import {before, describe, it} from 'node:test';
import type {Dialog} from 'puppeteer-core';
@@ -13,22 +14,134 @@ import type {ParsedArguments} from '../../src/bin/chrome-devtools-mcp-cli-option
import {loadIssueDescriptions} from '../../src/issue-descriptions.js';
import {McpResponse} from '../../src/McpResponse.js';
import {TextSnapshot} from '../../src/TextSnapshot.js';
+import type {CdpWebWorker} from '../../src/third_party/index.js';
import {DevTools} from '../../src/third_party/index.js';
import {
getConsoleMessage,
listConsoleMessages,
} from '../../src/tools/console.js';
+import {installExtension} from '../../src/tools/extensions.js';
import {serverHooks} from '../server.js';
import {
getTextContent,
withMcpContext,
stabilizeStructuredContent,
+ extractExtensionId,
+ assertNoServiceWorkerReported,
+ waitExecutionFor,
} from '../utils.js';
+const EXTENSION_LOGGING_PATH = path.join(
+ import.meta.dirname,
+ '../../../tests/tools/fixtures/extension-logging',
+);
+
describe('console', () => {
before(async () => {
await loadIssueDescriptions();
});
+
+ it('captures logs and errors from extension service worker', async t => {
+ await withMcpContext(
+ async (response, context) => {
+ await installExtension.handler(
+ {params: {path: EXTENSION_LOGGING_PATH}},
+ response,
+ context,
+ );
+
+ const extensionId = extractExtensionId(response);
+ assert.ok(extensionId, 'Extension ID should be returned');
+
+ const swTarget = await context.browser.waitForTarget(
+ t => t.type() === 'service_worker' && t.url().includes(extensionId),
+ );
+
+ const swList = await context.createExtensionServiceWorkersSnapshot();
+ const sw = swList.find(s => s.target === swTarget);
+ assert(sw, 'Service worker not found in context list');
+
+ const response2 = new McpResponse({} as ParsedArguments);
+
+ await context.triggerExtensionAction(extensionId);
+ const worker = await swTarget.worker();
+
+ const timeout = 10000;
+ await waitExecutionFor(async () => {
+ await worker?.evaluate(() => {
+ if (typeof globalThis.setTimeout !== 'function') {
+ throw new Error('Not ready');
+ }
+ });
+ }, timeout);
+
+ const errorPromise = new Promise((resolve, reject) => {
+ const timeout = setTimeout(() => {
+ reject(new Error('Timeout waiting for Service Worker error'));
+ }, 5000);
+ (worker as unknown as CdpWebWorker).client.on(
+ 'Runtime.exceptionThrown',
+ () => {
+ clearTimeout(timeout);
+ resolve(undefined);
+ },
+ );
+ });
+
+ worker?.evaluate(() => {
+ globalThis.setTimeout(() => {
+ throw new Error('Intentional error from Service Worker');
+ }, 100);
+ });
+
+ await errorPromise;
+ response2.resetResponseLineForTesting();
+
+ await listConsoleMessages({
+ categoryExtensions: true,
+ } as ParsedArguments).handler(
+ {
+ params: {serviceWorkerId: extensionId},
+ page: context.getSelectedMcpPage(),
+ },
+ response2,
+ context,
+ );
+
+ const formattedResponse = await response2.handle('test', context);
+ const textContent = getTextContent(formattedResponse.content[0]);
+
+ const sanitizedText = textContent.replaceAll(
+ new RegExp(extensionId, 'g'),
+ '<extension-id>',
+ );
+
+ t.assert.snapshot?.(sanitizedText);
+
+ assert.ok(
+ sanitizedText.includes('Service Worker starting...'),
+ 'Should contain start log',
+ );
+ assert.ok(
+ sanitizedText.includes('This is a warning from Service Worker'),
+ 'Should contain warning log',
+ );
+ assert.ok(
+ sanitizedText.includes('Intentional error from Service Worker'),
+ 'Should contain error log',
+ );
+
+ await context.uninstallExtension(extensionId);
+ const targets = context.browser.targets();
+ assertNoServiceWorkerReported(targets, extensionId);
+ },
+ {},
+ {
+ categoryExtensions: true,
+ } as ParsedArguments,
+ );
+ });
+
describe('list_console_messages', () => {
it('list messages', async () => {
await withMcpContext(async (response, context) => {
diff --git a/tests/tools/extensions.test.ts b/tests/tools/extensions.test.ts
index 59580ddd..d760be15 100644
--- a/tests/tools/extensions.test.ts
+++ b/tests/tools/extensions.test.ts
@@ -138,6 +138,7 @@ describe('extension', () => {
assert.ok(list.length === 1, 'List should have only one extension');
const reinstalled = list.find(e => e.id === extensionId);
assert.ok(reinstalled, 'Extension should be present after reload');
+ await context.uninstallExtension(extensionId!);
},
{},
{
diff --git a/tests/tools/fixtures/extension-logging/manifest.json b/tests/tools/fixtures/extension-logging/manifest.json
new file mode 100644
index 00000000..a11cf0ac
--- /dev/null
+++ b/tests/tools/fixtures/extension-logging/manifest.json
@@ -0,0 +1,8 @@
+{
+ "manifest_version": 3,
+ "name": "Test Extension for Logging",
+ "version": "1.0",
+ "background": {
+ "service_worker": "sw.js"
+ }
+}
diff --git a/tests/tools/fixtures/extension-logging/sw.js b/tests/tools/fixtures/extension-logging/sw.js
new file mode 100644
index 00000000..01ef54ef
--- /dev/null
+++ b/tests/tools/fixtures/extension-logging/sw.js
@@ -0,0 +1,3 @@
+// Minimal service worker for testing
+console.log('Service Worker starting...');
+console.warn('This is a warning from Service Worker');
diff --git a/tests/tools/script.test.ts b/tests/tools/script.test.ts
index 2718deb2..5f69e5de 100644
--- a/tests/tools/script.test.ts
+++ b/tests/tools/script.test.ts
@@ -332,6 +332,8 @@ describe('script', () => {
const swId = context.getExtensionServiceWorkerId(sw);
+ await context.triggerExtensionAction(extensionId);
+
response.resetResponseLineForTesting();
await evaluateScript({
categoryExtensions: true,
diff --git a/tests/utils.ts b/tests/utils.ts
index 41c188eb..a1863521 100644
--- a/tests/utils.ts
+++ b/tests/utils.ts
@@ -408,3 +408,20 @@ export async function assertDaemonIsRunning(sessionId?: string) {
'chrome-devtools-mcp daemon is not running',
);
}
+
+export async function waitExecutionFor(
+ func: () => Promise<void>,
+ timeout: number,
+) {
+ const start = Date.now();
+ while (Date.now() - start < 10000) {
+ try {
+ await func();
+ return;
+ } catch {
+ await new Promise(resolve => setTimeout(resolve, 100)); // wait and retry
+ }
+ }
+
+ throw new Error(`Timeout of ${timeout} reached.`);
+}