@vellumai/assistant 0.3.0

package/src/__tests__/headless-browser-navigate.test.ts

@@ -0,0 +1,211 @@
+import { describe, test, expect, beforeEach, mock } from 'bun:test';
+
+// ── Mocks ────────────────────────────────────────────────────────────
+
+mock.module('../util/logger.js', () => ({
+  getLogger: () => new Proxy({} as Record<string, unknown>, {
+    get: () => () => {},
+  }),
+}));
+
+mock.module('../util/platform.js', () => ({
+  getDataDir: () => '/tmp/headless-browser-test',
+}));
+
+// Track calls to browserManager and url-safety helpers
+let mockPage: {
+  goto: ReturnType<typeof mock>;
+  title: ReturnType<typeof mock>;
+  url: ReturnType<typeof mock>;
+  route: ReturnType<typeof mock>;
+  unroute: ReturnType<typeof mock>;
+  close: () => Promise<void>;
+  isClosed: () => boolean;
+};
+
+let getOrCreateSessionPageMock: ReturnType<typeof mock>;
+
+mock.module('../tools/browser/browser-manager.js', () => {
+  getOrCreateSessionPageMock = mock(async () => mockPage);
+  return {
+    browserManager: {
+      getOrCreateSessionPage: getOrCreateSessionPageMock,
+      clearSnapshotMap: mock(() => {}),
+      supportsRouteInterception: true,
+    },
+  };
+});
+
+// Default url-safety: allow everything
+let parseUrlResult: URL | null = null;
+let isPrivateResult = false;
+let resolveResult: { blockedAddress?: string } = {};
+
+mock.module('../tools/network/url-safety.js', () => ({
+  parseUrl: (_input: unknown) => parseUrlResult,
+  isPrivateOrLocalHost: () => isPrivateResult,
+  resolveHostAddresses: async () => [],
+  resolveRequestAddress: async () => resolveResult,
+  sanitizeUrlForOutput: (url: URL) => url.href,
+}));
+
+import { executeBrowserNavigate } from '../tools/browser/headless-browser.js';
+import type { ToolContext } from '../tools/types.js';
+
+const ctx: ToolContext = {
+  sessionId: 'test-session',
+  conversationId: 'test-conversation',
+  workingDir: '/tmp',
+};
+
+function resetMockPage() {
+  mockPage = {
+    goto: mock(async () => ({ status: () => 200, url: () => 'https://example.com/' })),
+    title: mock(async () => 'Example'),
+    url: mock(() => 'https://example.com/'),
+    route: mock(async () => {}),
+    unroute: mock(async () => {}),
+    close: async () => {},
+    isClosed: () => false,
+  };
+}
+
+describe('executeBrowserNavigate', () => {
+  beforeEach(() => {
+    parseUrlResult = null;
+    isPrivateResult = false;
+    resolveResult = {};
+    resetMockPage();
+  });
+
+  // ── Input validation ───────────────────────────────────────────
+
+  test('rejects missing or invalid url', async () => {
+    const result = await executeBrowserNavigate({}, ctx);
+    expect(result.isError).toBe(true);
+    expect(result.content).toContain('url is required');
+  });
+
+  test('rejects non-http(s) protocols', async () => {
+    parseUrlResult = new URL('ftp://example.com');
+    const result = await executeBrowserNavigate({ url: 'ftp://example.com' }, ctx);
+    expect(result.isError).toBe(true);
+    expect(result.content).toContain('http or https');
+  });
+
+  // ── Private network blocking ───────────────────────────────────
+
+  test('blocks private/local hosts by default', async () => {
+    parseUrlResult = new URL('http://localhost:3000');
+    isPrivateResult = true;
+    const result = await executeBrowserNavigate({ url: 'http://localhost:3000' }, ctx);
+    expect(result.isError).toBe(true);
+    expect(result.content).toContain('Refusing to navigate');
+    expect(result.content).toContain('localhost');
+  });
+
+  test('allows private hosts with allow_private_network=true', async () => {
+    parseUrlResult = new URL('http://localhost:3000');
+    isPrivateResult = true;
+    const result = await executeBrowserNavigate(
+      { url: 'http://localhost:3000', allow_private_network: true },
+      ctx,
+    );
+    expect(result.isError).toBe(false);
+    expect(result.content).toContain('Status: 200');
+  });
+
+  test('blocks DNS-resolved private addresses by default', async () => {
+    parseUrlResult = new URL('https://internal.corp.example.com');
+    isPrivateResult = false;
+    resolveResult = { blockedAddress: '10.0.0.1' };
+    const result = await executeBrowserNavigate(
+      { url: 'https://internal.corp.example.com' },
+      ctx,
+    );
+    expect(result.isError).toBe(true);
+    expect(result.content).toContain('10.0.0.1');
+  });
+
+  test('skips DNS check with allow_private_network=true', async () => {
+    parseUrlResult = new URL('https://internal.corp.example.com');
+    isPrivateResult = false;
+    resolveResult = { blockedAddress: '10.0.0.1' };
+    const result = await executeBrowserNavigate(
+      { url: 'https://internal.corp.example.com', allow_private_network: true },
+      ctx,
+    );
+    expect(result.isError).toBe(false);
+    expect(result.content).toContain('Status: 200');
+  });
+
+  // ── Successful navigation ──────────────────────────────────────
+
+  test('returns structured result on success', async () => {
+    parseUrlResult = new URL('https://example.com/page');
+    const result = await executeBrowserNavigate({ url: 'https://example.com/page' }, ctx);
+    expect(result.isError).toBe(false);
+    expect(result.content).toContain('Requested URL:');
+    expect(result.content).toContain('Final URL:');
+    expect(result.content).toContain('Status: 200');
+    expect(result.content).toContain('Title: Example');
+  });
+
+  test('notes redirect when final URL differs', async () => {
+    parseUrlResult = new URL('https://example.com/old');
+    mockPage.url = mock(() => 'https://example.com/new');
+    const result = await executeBrowserNavigate({ url: 'https://example.com/old' }, ctx);
+    expect(result.isError).toBe(false);
+    expect(result.content).toContain('redirected');
+  });
+
+  test('handles null response status', async () => {
+    parseUrlResult = new URL('https://example.com');
+    mockPage.goto = mock(async () => null);
+    const result = await executeBrowserNavigate({ url: 'https://example.com' }, ctx);
+    expect(result.isError).toBe(false);
+    expect(result.content).toContain('Status: unknown');
+  });
+
+  // ── Error handling ─────────────────────────────────────────────
+
+  test('catches navigation errors', async () => {
+    parseUrlResult = new URL('https://example.com');
+    mockPage.goto = mock(async () => { throw new Error('net::ERR_CONNECTION_REFUSED'); });
+    const result = await executeBrowserNavigate({ url: 'https://example.com' }, ctx);
+    expect(result.isError).toBe(true);
+    expect(result.content).toContain('Navigation failed');
+    expect(result.content).toContain('ERR_CONNECTION_REFUSED');
+  });
+
+  test('returns security message when route handler blocks a redirect and goto throws', async () => {
+    parseUrlResult = new URL('https://public.example.com');
+    isPrivateResult = false;
+
+    // Capture the route handler when page.route is called
+    let capturedHandler: ((route: unknown, request: unknown) => Promise<void>) | null = null;
+    mockPage.route = mock(async (_pattern: string, handler: (route: unknown, request: unknown) => Promise<void>) => {
+      capturedHandler = handler;
+    });
+
+    // Make goto invoke the captured handler with a private redirect target, then throw
+    mockPage.goto = mock(async () => {
+      if (capturedHandler) {
+        // Temporarily make isPrivateOrLocalHost return true for the redirect target
+        isPrivateResult = true;
+        const mockRoute = { abort: mock(async () => {}), continue: mock(async () => {}) };
+        const mockRequest = { url: () => 'http://169.254.169.254/metadata' };
+        await capturedHandler(mockRoute, mockRequest);
+        isPrivateResult = false;
+      }
+      throw new Error('net::ERR_BLOCKED_BY_CLIENT');
+    });
+
+    const result = await executeBrowserNavigate({ url: 'https://public.example.com' }, ctx);
+    expect(result.isError).toBe(true);
+    expect(result.content).toContain('Navigation blocked');
+    expect(result.content).toContain('allow_private_network=true');
+    // Should NOT contain the raw Playwright error
+    expect(result.content).not.toContain('ERR_BLOCKED_BY_CLIENT');
+  });
+});

package/src/__tests__/headless-browser-read-tools.test.ts

@@ -0,0 +1,261 @@
+import { describe, test, expect, beforeEach, mock } from 'bun:test';
+
+// ── Mocks ────────────────────────────────────────────────────────────
+
+mock.module('../util/logger.js', () => ({
+  getLogger: () => new Proxy({} as Record<string, unknown>, {
+    get: () => () => {},
+  }),
+}));
+
+mock.module('../util/platform.js', () => ({
+  getDataDir: () => '/tmp/headless-browser-read-tools-test',
+}));
+
+let mockPage: {
+  click: ReturnType<typeof mock>;
+  fill: ReturnType<typeof mock>;
+  press: ReturnType<typeof mock>;
+  evaluate: ReturnType<typeof mock>;
+  title: ReturnType<typeof mock>;
+  url: ReturnType<typeof mock>;
+  goto: ReturnType<typeof mock>;
+  close: () => Promise<void>;
+  isClosed: () => boolean;
+  waitForSelector: ReturnType<typeof mock>;
+  waitForFunction: ReturnType<typeof mock>;
+  keyboard: { press: ReturnType<typeof mock> };
+};
+
+let snapshotMaps: Map<string, Map<string, string>>;
+
+mock.module('../tools/browser/browser-manager.js', () => {
+  snapshotMaps = new Map();
+  return {
+    browserManager: {
+      getOrCreateSessionPage: async () => mockPage,
+      closeSessionPage: async () => {},
+      closeAllPages: async () => {},
+      storeSnapshotMap: (sessionId: string, map: Map<string, string>) => {
+        snapshotMaps.set(sessionId, map);
+      },
+      resolveSnapshotSelector: (sessionId: string, elementId: string) => {
+        const map = snapshotMaps.get(sessionId);
+        if (!map) return null;
+        return map.get(elementId) ?? null;
+      },
+    },
+  };
+});
+
+mock.module('../tools/network/url-safety.js', () => ({
+  parseUrl: () => null,
+  isPrivateOrLocalHost: () => false,
+  resolveHostAddresses: async () => [],
+  resolveRequestAddress: async () => ({}),
+  sanitizeUrlForOutput: (url: URL) => url.href,
+}));
+
+import {
+  executeBrowserPressKey,
+  executeBrowserWaitFor,
+  executeBrowserExtract,
+} from '../tools/browser/headless-browser.js';
+import type { ToolContext } from '../tools/types.js';
+
+const ctx: ToolContext = {
+  sessionId: 'test-session',
+  conversationId: 'test-conversation',
+  workingDir: '/tmp',
+};
+
+function resetMockPage() {
+  mockPage = {
+    click: mock(async () => {}),
+    fill: mock(async () => {}),
+    press: mock(async () => {}),
+    evaluate: mock(async () => ''),
+    title: mock(async () => 'Test Page'),
+    url: mock(() => 'https://example.com/'),
+    goto: mock(async () => ({ status: () => 200, url: () => 'https://example.com/' })),
+    close: async () => {},
+    isClosed: () => false,
+    waitForSelector: mock(async () => null),
+    waitForFunction: mock(async () => null),
+    keyboard: { press: mock(async () => {}) },
+  };
+}
+
+// ── browser_press_key ────────────────────────────────────────────────
+
+describe('executeBrowserPressKey', () => {
+  beforeEach(() => {
+    resetMockPage();
+    snapshotMaps.clear();
+  });
+
+  test('presses key on focused element (no target)', async () => {
+    const result = await executeBrowserPressKey({ key: 'Enter' }, ctx);
+    expect(result.isError).toBe(false);
+    expect(result.content).toContain('Pressed "Enter"');
+    expect(mockPage.keyboard.press).toHaveBeenCalledWith('Enter');
+  });
+
+  test('presses key on targeted element via element_id', async () => {
+    snapshotMaps.set('test-session', new Map([['e1', '[data-vellum-eid="e1"]']]));
+    const result = await executeBrowserPressKey({ key: 'Tab', element_id: 'e1' }, ctx);
+    expect(result.isError).toBe(false);
+    expect(result.content).toContain('Pressed "Tab" on element');
+    expect(mockPage.press).toHaveBeenCalledWith('[data-vellum-eid="e1"]', 'Tab');
+  });
+
+  test('presses key on targeted element via selector', async () => {
+    const result = await executeBrowserPressKey({ key: 'Escape', selector: '#modal' }, ctx);
+    expect(result.isError).toBe(false);
+    expect(mockPage.press).toHaveBeenCalledWith('#modal', 'Escape');
+  });
+
+  test('errors when key is missing', async () => {
+    const result = await executeBrowserPressKey({}, ctx);
+    expect(result.isError).toBe(true);
+    expect(result.content).toContain('key is required');
+  });
+
+  test('errors when element_id not found', async () => {
+    const result = await executeBrowserPressKey({ key: 'Enter', element_id: 'e99' }, ctx);
+    expect(result.isError).toBe(true);
+    expect(result.content).toContain('element_id "e99" not found');
+  });
+
+  test('handles press error', async () => {
+    mockPage.keyboard.press = mock(async () => { throw new Error('key not recognized'); });
+    const result = await executeBrowserPressKey({ key: 'InvalidKey' }, ctx);
+    expect(result.isError).toBe(true);
+    expect(result.content).toContain('Press key failed');
+  });
+});
+
+// ── browser_wait_for ─────────────────────────────────────────────────
+
+describe('executeBrowserWaitFor', () => {
+  beforeEach(() => {
+    resetMockPage();
+  });
+
+  test('waits for selector', async () => {
+    const result = await executeBrowserWaitFor({ selector: '#loaded' }, ctx);
+    expect(result.isError).toBe(false);
+    expect(result.content).toContain('Element matching "#loaded" appeared');
+    expect(mockPage.waitForSelector).toHaveBeenCalledWith('#loaded', { timeout: 30_000 });
+  });
+
+  test('waits for text', async () => {
+    const result = await executeBrowserWaitFor({ text: 'Success' }, ctx);
+    expect(result.isError).toBe(false);
+    expect(result.content).toContain('Text "Success" appeared');
+    expect(mockPage.waitForFunction).toHaveBeenCalled();
+  });
+
+  test('waits for duration', async () => {
+    const result = await executeBrowserWaitFor({ duration: 10 }, ctx);
+    expect(result.isError).toBe(false);
+    expect(result.content).toContain('Waited 10ms');
+  });
+
+  test('errors when no mode specified', async () => {
+    const result = await executeBrowserWaitFor({}, ctx);
+    expect(result.isError).toBe(true);
+    expect(result.content).toContain('Exactly one of selector, text, or duration');
+  });
+
+  test('errors when multiple modes specified', async () => {
+    const result = await executeBrowserWaitFor({ selector: '#x', text: 'y' }, ctx);
+    expect(result.isError).toBe(true);
+    expect(result.content).toContain('exactly one');
+  });
+
+  test('respects custom timeout', async () => {
+    const result = await executeBrowserWaitFor({ selector: '#el', timeout: 5000 }, ctx);
+    expect(result.isError).toBe(false);
+    expect(mockPage.waitForSelector).toHaveBeenCalledWith('#el', { timeout: 5000 });
+  });
+
+  test('caps duration at MAX_WAIT_MS', async () => {
+    // Use a small duration to verify the cap logic without actually waiting 30s.
+    // duration=50 is below the cap, so it should wait exactly 50ms.
+    const result = await executeBrowserWaitFor({ duration: 50 }, ctx);
+    expect(result.isError).toBe(false);
+    expect(result.content).toContain('Waited 50ms');
+  });
+
+  test('handles wait error (timeout)', async () => {
+    mockPage.waitForSelector = mock(async () => { throw new Error('Timeout 30000ms exceeded'); });
+    const result = await executeBrowserWaitFor({ selector: '#missing' }, ctx);
+    expect(result.isError).toBe(true);
+    expect(result.content).toContain('Wait failed');
+    expect(result.content).toContain('Timeout');
+  });
+});
+
+// ── browser_extract ──────────────────────────────────────────────────
+
+describe('executeBrowserExtract', () => {
+  beforeEach(() => {
+    resetMockPage();
+  });
+
+  test('extracts page text content', async () => {
+    mockPage.evaluate = mock(async () => 'Hello World');
+    const result = await executeBrowserExtract({}, ctx);
+    expect(result.isError).toBe(false);
+    expect(result.content).toContain('URL: https://example.com/');
+    expect(result.content).toContain('Title: Test Page');
+    expect(result.content).toContain('Hello World');
+  });
+
+  test('shows (empty page) for empty content', async () => {
+    mockPage.evaluate = mock(async () => '');
+    const result = await executeBrowserExtract({}, ctx);
+    expect(result.content).toContain('(empty page)');
+  });
+
+  test('truncates long content', async () => {
+    const longText = 'x'.repeat(60_000);
+    mockPage.evaluate = mock(async () => longText);
+    const result = await executeBrowserExtract({}, ctx);
+    expect(result.content).toContain('... (truncated)');
+    // Content should be capped
+    expect(result.content.length).toBeLessThan(60_000);
+  });
+
+  test('includes links when requested', async () => {
+    let callCount = 0;
+    mockPage.evaluate = mock(async () => {
+      callCount++;
+      if (callCount === 1) return 'Page text';
+      return [
+        { text: 'About', href: 'https://example.com/about' },
+        { text: 'Contact', href: 'https://example.com/contact' },
+      ];
+    });
+
+    const result = await executeBrowserExtract({ include_links: true }, ctx);
+    expect(result.isError).toBe(false);
+    expect(result.content).toContain('Links:');
+    expect(result.content).toContain('[About](https://example.com/about)');
+    expect(result.content).toContain('[Contact](https://example.com/contact)');
+  });
+
+  test('does not include links by default', async () => {
+    mockPage.evaluate = mock(async () => 'Page text');
+    const result = await executeBrowserExtract({}, ctx);
+    expect(result.content).not.toContain('Links:');
+  });
+
+  test('handles extract error', async () => {
+    mockPage.evaluate = mock(async () => { throw new Error('page crashed'); });
+    const result = await executeBrowserExtract({}, ctx);
+    expect(result.isError).toBe(true);
+    expect(result.content).toContain('Extract failed');
+  });
+});

package/src/__tests__/headless-browser-snapshot.test.ts

@@ -0,0 +1,185 @@
+import { describe, test, expect, beforeEach, mock } from 'bun:test';
+
+// ── Mocks ────────────────────────────────────────────────────────────
+
+mock.module('../util/logger.js', () => ({
+  getLogger: () => new Proxy({} as Record<string, unknown>, {
+    get: () => () => {},
+  }),
+}));
+
+mock.module('../util/platform.js', () => ({
+  getDataDir: () => '/tmp/headless-browser-snapshot-test',
+}));
+
+let mockPage: {
+  evaluate: ReturnType<typeof mock>;
+  title: ReturnType<typeof mock>;
+  url: ReturnType<typeof mock>;
+  goto: ReturnType<typeof mock>;
+  close: ReturnType<typeof mock>;
+  isClosed: () => boolean;
+};
+
+let closeSessionPageMock: ReturnType<typeof mock>;
+let closeAllPagesMock: ReturnType<typeof mock>;
+let storeSnapshotMapMock: ReturnType<typeof mock>;
+let storedMaps: Map<string, Map<string, string>>;
+
+mock.module('../tools/browser/browser-manager.js', () => {
+  storedMaps = new Map();
+  closeSessionPageMock = mock(async () => {});
+  closeAllPagesMock = mock(async () => {});
+  storeSnapshotMapMock = mock((sessionId: string, map: Map<string, string>) => {
+    storedMaps.set(sessionId, map);
+  });
+  return {
+    browserManager: {
+      getOrCreateSessionPage: async () => mockPage,
+      closeSessionPage: closeSessionPageMock,
+      closeAllPages: closeAllPagesMock,
+      storeSnapshotMap: storeSnapshotMapMock,
+      resolveSnapshotSelector: (sessionId: string, elementId: string) => {
+        const map = storedMaps.get(sessionId);
+        if (!map) return null;
+        return map.get(elementId) ?? null;
+      },
+    },
+  };
+});
+
+mock.module('../tools/network/url-safety.js', () => ({
+  parseUrl: () => null,
+  isPrivateOrLocalHost: () => false,
+  resolveHostAddresses: async () => [],
+  resolveRequestAddress: async () => ({}),
+  sanitizeUrlForOutput: (url: URL) => url.href,
+}));
+
+import {
+  executeBrowserSnapshot,
+  executeBrowserClose,
+} from '../tools/browser/headless-browser.js';
+import type { ToolContext } from '../tools/types.js';
+
+const ctx: ToolContext = {
+  sessionId: 'test-session',
+  conversationId: 'test-conversation',
+  workingDir: '/tmp',
+};
+
+function resetMockPage() {
+  mockPage = {
+    evaluate: mock(async () => []),
+    title: mock(async () => 'Test Page'),
+    url: mock(() => 'https://example.com/'),
+    goto: mock(async () => ({ status: () => 200, url: () => 'https://example.com/' })),
+    close: mock(async () => {}),
+    isClosed: () => false,
+  };
+}
+
+// ── browser_snapshot ─────────────────────────────────────────────────
+
+describe('executeBrowserSnapshot', () => {
+  beforeEach(() => {
+    resetMockPage();
+    storedMaps.clear();
+    storeSnapshotMapMock.mockClear();
+  });
+
+  test('returns page URL and title with no elements', async () => {
+    const result = await executeBrowserSnapshot({}, ctx);
+    expect(result.isError).toBe(false);
+    expect(result.content).toContain('URL: https://example.com/');
+    expect(result.content).toContain('Title: Test Page');
+    expect(result.content).toContain('(no interactive elements found)');
+  });
+
+  test('lists interactive elements with element IDs', async () => {
+    mockPage.evaluate = mock(async () => [
+      { eid: 'e1', tag: 'a', attrs: { href: '/about' }, text: 'About Us' },
+      { eid: 'e2', tag: 'button', attrs: {}, text: 'Submit' },
+      { eid: 'e3', tag: 'input', attrs: { type: 'text', name: 'email', placeholder: 'Email' }, text: '' },
+    ]);
+
+    const result = await executeBrowserSnapshot({}, ctx);
+    expect(result.isError).toBe(false);
+    expect(result.content).toContain('[e1] <a href="/about"> About Us');
+    expect(result.content).toContain('[e2] <button> Submit');
+    expect(result.content).toContain('[e3] <input type="text" name="email" placeholder="Email">');
+    expect(result.content).toContain('3 interactive elements found.');
+  });
+
+  test('stores selector map in browser manager', async () => {
+    mockPage.evaluate = mock(async () => [
+      { eid: 'e1', tag: 'a', attrs: { href: '/' }, text: 'Home' },
+      { eid: 'e2', tag: 'button', attrs: {}, text: 'OK' },
+    ]);
+
+    await executeBrowserSnapshot({}, ctx);
+    expect(storeSnapshotMapMock).toHaveBeenCalledTimes(1);
+
+    const stored = storedMaps.get('test-session');
+    expect(stored).toBeDefined();
+    expect(stored!.get('e1')).toBe('[data-vellum-eid="e1"]');
+    expect(stored!.get('e2')).toBe('[data-vellum-eid="e2"]');
+  });
+
+  test('handles single element with singular count', async () => {
+    mockPage.evaluate = mock(async () => [
+      { eid: 'e1', tag: 'button', attrs: {}, text: 'Click' },
+    ]);
+
+    const result = await executeBrowserSnapshot({}, ctx);
+    expect(result.content).toContain('1 interactive element found.');
+  });
+
+  test('handles evaluate error', async () => {
+    mockPage.evaluate = mock(async () => { throw new Error('page crashed'); });
+    const result = await executeBrowserSnapshot({}, ctx);
+    expect(result.isError).toBe(true);
+    expect(result.content).toContain('Snapshot failed');
+    expect(result.content).toContain('page crashed');
+  });
+
+  test('shows (none) for empty title', async () => {
+    mockPage.title = mock(async () => '');
+    const result = await executeBrowserSnapshot({}, ctx);
+    expect(result.content).toContain('Title: (none)');
+  });
+});
+
+// ── browser_close ────────────────────────────────────────────────────
+
+describe('executeBrowserClose', () => {
+  beforeEach(() => {
+    resetMockPage();
+    closeSessionPageMock.mockClear();
+    closeAllPagesMock.mockClear();
+  });
+
+  test('closes session page by default', async () => {
+    const result = await executeBrowserClose({}, ctx);
+    expect(result.isError).toBe(false);
+    expect(result.content).toContain('Browser page closed for this session.');
+    expect(closeSessionPageMock).toHaveBeenCalledWith('test-session');
+    expect(closeAllPagesMock).not.toHaveBeenCalled();
+  });
+
+  test('closes all pages with close_all_pages=true', async () => {
+    const result = await executeBrowserClose({ close_all_pages: true }, ctx);
+    expect(result.isError).toBe(false);
+    expect(result.content).toContain('All browser pages and context closed.');
+    expect(closeAllPagesMock).toHaveBeenCalledTimes(1);
+    expect(closeSessionPageMock).not.toHaveBeenCalled();
+  });
+
+  test('handles close error', async () => {
+    closeSessionPageMock.mockImplementation(async () => { throw new Error('close failed'); });
+    const result = await executeBrowserClose({}, ctx);
+    expect(result.isError).toBe(true);
+    expect(result.content).toContain('Close failed');
+    expect(result.content).toContain('close failed');
+  });
+});