@hotmeshio/long-tail 0.1.0

package/build/services/mcp/db.js

@@ -0,0 +1,141 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createMcpServer = createMcpServer;
+exports.getMcpServer = getMcpServer;
+exports.getMcpServerByName = getMcpServerByName;
+exports.updateMcpServer = updateMcpServer;
+exports.deleteMcpServer = deleteMcpServer;
+exports.updateMcpServerStatus = updateMcpServerStatus;
+exports.listMcpServers = listMcpServers;
+exports.getAutoConnectServers = getAutoConnectServers;
+exports.findServersByTags = findServersByTags;
+const db_1 = require("../db");
+const sql_1 = require("./sql");
+async function createMcpServer(input) {
+    const pool = (0, db_1.getPool)();
+    const { rows } = await pool.query(sql_1.CREATE_MCP_SERVER, [
+        input.name,
+        input.description || null,
+        input.transport_type,
+        JSON.stringify(input.transport_config),
+        input.auto_connect ?? false,
+        input.metadata ? JSON.stringify(input.metadata) : null,
+        input.tags || [],
+    ]);
+    return rows[0];
+}
+async function getMcpServer(id) {
+    const pool = (0, db_1.getPool)();
+    const { rows } = await pool.query(sql_1.GET_MCP_SERVER, [id]);
+    return rows[0] || null;
+}
+async function getMcpServerByName(name) {
+    const pool = (0, db_1.getPool)();
+    const { rows } = await pool.query(sql_1.GET_MCP_SERVER_BY_NAME, [name]);
+    return rows[0] || null;
+}
+async function updateMcpServer(id, updates) {
+    const pool = (0, db_1.getPool)();
+    const sets = [];
+    const values = [];
+    let idx = 1;
+    if (updates.name !== undefined) {
+        sets.push(`name = $${idx++}`);
+        values.push(updates.name);
+    }
+    if (updates.description !== undefined) {
+        sets.push(`description = $${idx++}`);
+        values.push(updates.description);
+    }
+    if (updates.transport_type !== undefined) {
+        sets.push(`transport_type = $${idx++}`);
+        values.push(updates.transport_type);
+    }
+    if (updates.transport_config !== undefined) {
+        sets.push(`transport_config = $${idx++}`);
+        values.push(JSON.stringify(updates.transport_config));
+    }
+    if (updates.auto_connect !== undefined) {
+        sets.push(`auto_connect = $${idx++}`);
+        values.push(updates.auto_connect);
+    }
+    if (updates.metadata !== undefined) {
+        sets.push(`metadata = $${idx++}`);
+        values.push(JSON.stringify(updates.metadata));
+    }
+    if (updates.tags !== undefined) {
+        sets.push(`tags = $${idx++}`);
+        values.push(updates.tags);
+    }
+    if (sets.length === 0)
+        return getMcpServer(id);
+    values.push(id);
+    const { rows } = await pool.query(`UPDATE lt_mcp_servers SET ${sets.join(', ')} WHERE id = $${idx} RETURNING *`, values);
+    return rows[0] || null;
+}
+async function deleteMcpServer(id) {
+    const pool = (0, db_1.getPool)();
+    const { rowCount } = await pool.query(sql_1.DELETE_MCP_SERVER, [id]);
+    return (rowCount || 0) > 0;
+}
+async function updateMcpServerStatus(id, status, toolManifest) {
+    const pool = (0, db_1.getPool)();
+    if (status === 'connected') {
+        await pool.query(sql_1.UPDATE_STATUS_CONNECTED, [id, status, toolManifest ? JSON.stringify(toolManifest) : null]);
+    }
+    else {
+        await pool.query(sql_1.UPDATE_STATUS, [id, status]);
+    }
+}
+async function listMcpServers(filters) {
+    const pool = (0, db_1.getPool)();
+    const conditions = [];
+    const values = [];
+    let idx = 1;
+    if (filters.status) {
+        conditions.push(`status = $${idx++}`);
+        values.push(filters.status);
+    }
+    if (filters.auto_connect !== undefined) {
+        conditions.push(`auto_connect = $${idx++}`);
+        values.push(filters.auto_connect);
+    }
+    if (filters.search) {
+        conditions.push(`(name ILIKE $${idx} OR description ILIKE $${idx} OR tool_manifest::text ILIKE $${idx})`);
+        values.push(`%${filters.search}%`);
+        idx++;
+    }
+    if (filters.tags?.length) {
+        conditions.push(`tags && $${idx++}::text[]`);
+        values.push(filters.tags);
+    }
+    const where = conditions.length ? `WHERE ${conditions.join(' AND ')}` : '';
+    const limit = filters.limit || 50;
+    const offset = filters.offset || 0;
+    const [countResult, dataResult] = await Promise.all([
+        pool.query(`SELECT COUNT(*) FROM lt_mcp_servers ${where}`, values),
+        pool.query(`SELECT * FROM lt_mcp_servers ${where} ORDER BY created_at DESC LIMIT $${idx++} OFFSET $${idx++}`, [...values, limit, offset]),
+    ]);
+    return {
+        servers: dataResult.rows,
+        total: parseInt(countResult.rows[0].count, 10),
+    };
+}
+async function getAutoConnectServers() {
+    const pool = (0, db_1.getPool)();
+    const { rows } = await pool.query(sql_1.GET_AUTO_CONNECT_SERVERS);
+    return rows;
+}
+/**
+ * Find MCP servers by tags.
+ * @param tags - Tags to filter by
+ * @param match - 'any' (OR — server has at least one tag) or 'all' (AND — server has all tags)
+ */
+async function findServersByTags(tags, match = 'any') {
+    if (!tags.length)
+        return [];
+    const pool = (0, db_1.getPool)();
+    const operator = match === 'all' ? '@>' : '&&';
+    const { rows } = await pool.query(`SELECT * FROM lt_mcp_servers WHERE tags ${operator} $1::text[] ORDER BY name`, [tags]);
+    return rows;
+}

package/build/services/mcp/index.d.ts

@@ -0,0 +1,25 @@
+import type { LTMcpAdapter } from '../../types/mcp';
+/**
+ * Singleton registry for the MCP adapter.
+ *
+ * Follows the same pattern as telemetryRegistry (single adapter):
+ * - register(adapter) — set the MCP adapter
+ * - connect()         — start server + connect clients
+ * - disconnect()      — stop server + disconnect clients
+ * - clear()           — reset (for tests)
+ *
+ * The built-in adapter manages both the Human Queue MCP server
+ * and client connections to external MCP servers.
+ */
+declare class LTMcpRegistry {
+    private adapter;
+    private connected;
+    register(adapter: LTMcpAdapter): void;
+    connect(): Promise<void>;
+    disconnect(): Promise<void>;
+    clear(): void;
+    get hasAdapter(): boolean;
+    get current(): LTMcpAdapter | null;
+}
+export declare const mcpRegistry: LTMcpRegistry;
+export {};

package/build/services/mcp/index.js

@@ -0,0 +1,47 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.mcpRegistry = void 0;
+/**
+ * Singleton registry for the MCP adapter.
+ *
+ * Follows the same pattern as telemetryRegistry (single adapter):
+ * - register(adapter) — set the MCP adapter
+ * - connect()         — start server + connect clients
+ * - disconnect()      — stop server + disconnect clients
+ * - clear()           — reset (for tests)
+ *
+ * The built-in adapter manages both the Human Queue MCP server
+ * and client connections to external MCP servers.
+ */
+class LTMcpRegistry {
+    constructor() {
+        this.adapter = null;
+        this.connected = false;
+    }
+    register(adapter) {
+        this.adapter = adapter;
+    }
+    async connect() {
+        if (this.connected || !this.adapter)
+            return;
+        await this.adapter.connect();
+        this.connected = true;
+    }
+    async disconnect() {
+        if (!this.adapter)
+            return;
+        await this.adapter.disconnect();
+        this.connected = false;
+    }
+    clear() {
+        this.adapter = null;
+        this.connected = false;
+    }
+    get hasAdapter() {
+        return this.adapter !== null;
+    }
+    get current() {
+        return this.adapter;
+    }
+}
+exports.mcpRegistry = new LTMcpRegistry();

package/build/services/mcp/playwright-server/index.d.ts

@@ -0,0 +1,14 @@
+import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+export { stopPlaywrightServer } from './lifecycle';
+/**
+ * Create a Playwright Browser MCP server.
+ *
+ * Provides 8 tools for browser automation:
+ *   navigate, screenshot, click, fill, wait_for, evaluate, list_pages, close_page
+ *
+ * Returns a fresh McpServer instance each time. The browser is shared
+ * and lazy-launched on first tool call.
+ */
+export declare function createPlaywrightServer(options?: {
+    name?: string;
+}): Promise<McpServer>;

package/build/services/mcp/playwright-server/index.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.stopPlaywrightServer = void 0;
+exports.createPlaywrightServer = createPlaywrightServer;
+const mcp_js_1 = require("@modelcontextprotocol/sdk/server/mcp.js");
+const logger_1 = require("../../logger");
+const tools_1 = require("./tools");
+var lifecycle_1 = require("./lifecycle");
+Object.defineProperty(exports, "stopPlaywrightServer", { enumerable: true, get: function () { return lifecycle_1.stopPlaywrightServer; } });
+/**
+ * Create a Playwright Browser MCP server.
+ *
+ * Provides 8 tools for browser automation:
+ *   navigate, screenshot, click, fill, wait_for, evaluate, list_pages, close_page
+ *
+ * Returns a fresh McpServer instance each time. The browser is shared
+ * and lazy-launched on first tool call.
+ */
+async function createPlaywrightServer(options) {
+    const name = options?.name || 'long-tail-playwright';
+    const instance = new mcp_js_1.McpServer({ name, version: '1.0.0' });
+    (0, tools_1.registerTools)(instance);
+    logger_1.loggerRegistry.info(`[lt-mcp:playwright] ${name} ready (8 tools registered)`);
+    return instance;
+}

package/build/services/mcp/playwright-server/lifecycle.d.ts

@@ -0,0 +1,7 @@
+import { type Browser, type Page } from 'playwright';
+export declare const pages: Map<string, Page>;
+export declare function ensureBrowser(): Promise<Browser>;
+export declare function allocatePageId(): string;
+export declare function getPage(pageId?: string): Page;
+export declare function getPageId(pageId?: string): string;
+export declare function stopPlaywrightServer(): Promise<void>;

package/build/services/mcp/playwright-server/lifecycle.js

@@ -0,0 +1,63 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.pages = void 0;
+exports.ensureBrowser = ensureBrowser;
+exports.allocatePageId = allocatePageId;
+exports.getPage = getPage;
+exports.getPageId = getPageId;
+exports.stopPlaywrightServer = stopPlaywrightServer;
+const playwright_1 = require("playwright");
+const logger_1 = require("../../logger");
+// Browser lifecycle: shared instance across tool calls within a single
+// server lifetime. Lazy-launched on first use, cleaned up via
+// stopPlaywrightServer().
+let browser = null;
+exports.pages = new Map();
+let pageCounter = 0;
+async function ensureBrowser() {
+    if (!browser || !browser.isConnected()) {
+        browser = await playwright_1.chromium.launch({ headless: true });
+        logger_1.loggerRegistry.info('[lt-mcp:playwright] browser launched');
+    }
+    return browser;
+}
+function allocatePageId() {
+    return `page_${++pageCounter}`;
+}
+// Page lookup helpers
+function getPage(pageId) {
+    if (pageId) {
+        const page = exports.pages.get(pageId);
+        if (!page)
+            throw new Error(`Page not found: ${pageId}`);
+        return page;
+    }
+    const entries = Array.from(exports.pages.entries());
+    if (entries.length === 0)
+        throw new Error('No pages open. Navigate to a URL first.');
+    return entries[entries.length - 1][1];
+}
+function getPageId(pageId) {
+    if (pageId)
+        return pageId;
+    const entries = Array.from(exports.pages.entries());
+    if (entries.length === 0)
+        throw new Error('No pages open');
+    return entries[entries.length - 1][0];
+}
+// Shutdown: close all pages and the browser.
+async function stopPlaywrightServer() {
+    for (const [id, page] of exports.pages) {
+        try {
+            await page.close();
+        }
+        catch { /* ignore */ }
+        exports.pages.delete(id);
+    }
+    if (browser) {
+        await browser.close();
+        browser = null;
+    }
+    pageCounter = 0;
+    logger_1.loggerRegistry.info('[lt-mcp:playwright] browser closed');
+}

package/build/services/mcp/playwright-server/schemas.d.ts

@@ -0,0 +1,81 @@
+import { z } from 'zod';
+export declare const navigateSchema: z.ZodObject<{
+    url: z.ZodString;
+    wait_until: z.ZodOptional<z.ZodEnum<["load", "domcontentloaded", "networkidle"]>>;
+}, "strip", z.ZodTypeAny, {
+    url: string;
+    wait_until?: "load" | "domcontentloaded" | "networkidle" | undefined;
+}, {
+    url: string;
+    wait_until?: "load" | "domcontentloaded" | "networkidle" | undefined;
+}>;
+export declare const screenshotSchema: z.ZodObject<{
+    page_id: z.ZodOptional<z.ZodString>;
+    path: z.ZodString;
+    full_page: z.ZodOptional<z.ZodBoolean>;
+    selector: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    path: string;
+    page_id?: string | undefined;
+    selector?: string | undefined;
+    full_page?: boolean | undefined;
+}, {
+    path: string;
+    page_id?: string | undefined;
+    selector?: string | undefined;
+    full_page?: boolean | undefined;
+}>;
+export declare const clickSchema: z.ZodObject<{
+    page_id: z.ZodOptional<z.ZodString>;
+    selector: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    selector: string;
+    page_id?: string | undefined;
+}, {
+    selector: string;
+    page_id?: string | undefined;
+}>;
+export declare const fillSchema: z.ZodObject<{
+    page_id: z.ZodOptional<z.ZodString>;
+    selector: z.ZodString;
+    value: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    value: string;
+    selector: string;
+    page_id?: string | undefined;
+}, {
+    value: string;
+    selector: string;
+    page_id?: string | undefined;
+}>;
+export declare const waitForSchema: z.ZodObject<{
+    page_id: z.ZodOptional<z.ZodString>;
+    selector: z.ZodString;
+    timeout: z.ZodOptional<z.ZodNumber>;
+}, "strip", z.ZodTypeAny, {
+    selector: string;
+    timeout?: number | undefined;
+    page_id?: string | undefined;
+}, {
+    selector: string;
+    timeout?: number | undefined;
+    page_id?: string | undefined;
+}>;
+export declare const evaluateSchema: z.ZodObject<{
+    page_id: z.ZodOptional<z.ZodString>;
+    script: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    script: string;
+    page_id?: string | undefined;
+}, {
+    script: string;
+    page_id?: string | undefined;
+}>;
+export declare const listPagesSchema: z.ZodObject<{}, "strip", z.ZodTypeAny, {}, {}>;
+export declare const closePageSchema: z.ZodObject<{
+    page_id: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    page_id: string;
+}, {
+    page_id: string;
+}>;

package/build/services/mcp/playwright-server/schemas.js

@@ -0,0 +1,48 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.closePageSchema = exports.listPagesSchema = exports.evaluateSchema = exports.waitForSchema = exports.fillSchema = exports.clickSchema = exports.screenshotSchema = exports.navigateSchema = void 0;
+const zod_1 = require("zod");
+// Zod schemas extracted to break TS2589 deep-instantiation cycles.
+exports.navigateSchema = zod_1.z.object({
+    url: zod_1.z.string().describe('URL to navigate to'),
+    wait_until: zod_1.z.enum(['load', 'domcontentloaded', 'networkidle']).optional()
+        .describe('When to consider navigation complete (default: load)'),
+});
+exports.screenshotSchema = zod_1.z.object({
+    page_id: zod_1.z.string().optional()
+        .describe('Page to screenshot (default: most recent)'),
+    path: zod_1.z.string()
+        .describe('File path to save the screenshot PNG'),
+    full_page: zod_1.z.boolean().optional()
+        .describe('Capture the full scrollable page (default: false)'),
+    selector: zod_1.z.string().optional()
+        .describe('CSS selector to screenshot a specific element'),
+});
+exports.clickSchema = zod_1.z.object({
+    page_id: zod_1.z.string().optional()
+        .describe('Page to act on (default: most recent)'),
+    selector: zod_1.z.string().describe('CSS selector of the element to click'),
+});
+exports.fillSchema = zod_1.z.object({
+    page_id: zod_1.z.string().optional()
+        .describe('Page to act on (default: most recent)'),
+    selector: zod_1.z.string().describe('CSS selector of the input element'),
+    value: zod_1.z.string().describe('Value to type into the input'),
+});
+exports.waitForSchema = zod_1.z.object({
+    page_id: zod_1.z.string().optional()
+        .describe('Page to act on (default: most recent)'),
+    selector: zod_1.z.string().describe('CSS selector to wait for'),
+    timeout: zod_1.z.number().optional()
+        .describe('Max wait time in ms (default: 10000)'),
+});
+exports.evaluateSchema = zod_1.z.object({
+    page_id: zod_1.z.string().optional()
+        .describe('Page to act on (default: most recent)'),
+    script: zod_1.z.string()
+        .describe('JavaScript expression to evaluate in the page context'),
+});
+exports.listPagesSchema = zod_1.z.object({});
+exports.closePageSchema = zod_1.z.object({
+    page_id: zod_1.z.string().describe('Page ID to close'),
+});

package/build/services/mcp/playwright-server/tools.d.ts

@@ -0,0 +1,2 @@
+import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+export declare function registerTools(srv: McpServer): void;

package/build/services/mcp/playwright-server/tools.js

@@ -0,0 +1,224 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.registerTools = registerTools;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const logger_1 = require("../../logger");
+const schemas_1 = require("./schemas");
+const lifecycle_1 = require("./lifecycle");
+// Tool-handler registration for the Playwright MCP server.
+function registerTools(srv) {
+    // ── navigate ─────────────────────────────────────────────
+    srv.registerTool('navigate', {
+        title: 'Navigate to URL',
+        description: 'Open a URL in a new browser page. Returns the page ID for subsequent tool calls.',
+        inputSchema: schemas_1.navigateSchema,
+    }, async (args) => {
+        const b = await (0, lifecycle_1.ensureBrowser)();
+        const page = await b.newPage();
+        const id = (0, lifecycle_1.allocatePageId)();
+        lifecycle_1.pages.set(id, page);
+        await page.goto(args.url, {
+            waitUntil: args.wait_until || 'load',
+            timeout: 30_000,
+        });
+        const title = await page.title();
+        return {
+            content: [{
+                    type: 'text',
+                    text: JSON.stringify({ page_id: id, url: args.url, title }),
+                }],
+        };
+    });
+    // ── screenshot ───────────────────────────────────────────
+    srv.registerTool('screenshot', {
+        title: 'Take Screenshot',
+        description: 'Capture a screenshot of the current page (or a specific element) and save it as a PNG file.',
+        inputSchema: schemas_1.screenshotSchema,
+    }, async (args) => {
+        const page = (0, lifecycle_1.getPage)(args.page_id);
+        const pageId = (0, lifecycle_1.getPageId)(args.page_id);
+        const dir = path.dirname(args.path);
+        if (!fs.existsSync(dir)) {
+            fs.mkdirSync(dir, { recursive: true });
+        }
+        if (args.selector) {
+            const element = await page.$(args.selector);
+            if (!element) {
+                return {
+                    content: [{
+                            type: 'text',
+                            text: JSON.stringify({ error: `Element not found: ${args.selector}` }),
+                        }],
+                    isError: true,
+                };
+            }
+            await element.screenshot({ path: args.path });
+        }
+        else {
+            await page.screenshot({
+                path: args.path,
+                fullPage: args.full_page ?? false,
+            });
+        }
+        const stats = fs.statSync(args.path);
+        logger_1.loggerRegistry.info(`[lt-mcp:playwright] screenshot saved: ${args.path} (${stats.size} bytes)`);
+        return {
+            content: [{
+                    type: 'text',
+                    text: JSON.stringify({
+                        page_id: pageId,
+                        path: args.path,
+                        size_bytes: stats.size,
+                        url: page.url(),
+                    }),
+                }],
+        };
+    });
+    // ── click ────────────────────────────────────────────────
+    srv.registerTool('click', {
+        title: 'Click Element',
+        description: 'Click an element on the page by CSS selector.',
+        inputSchema: schemas_1.clickSchema,
+    }, async (args) => {
+        const page = (0, lifecycle_1.getPage)(args.page_id);
+        await page.click(args.selector, { timeout: 10_000 });
+        await page.waitForTimeout(500);
+        return {
+            content: [{
+                    type: 'text',
+                    text: JSON.stringify({
+                        clicked: args.selector,
+                        url: page.url(),
+                        title: await page.title(),
+                    }),
+                }],
+        };
+    });
+    // ── fill ─────────────────────────────────────────────────
+    srv.registerTool('fill', {
+        title: 'Fill Input',
+        description: 'Type a value into an input field by CSS selector. Clears existing content first.',
+        inputSchema: schemas_1.fillSchema,
+    }, async (args) => {
+        const page = (0, lifecycle_1.getPage)(args.page_id);
+        await page.fill(args.selector, args.value, { timeout: 10_000 });
+        return {
+            content: [{
+                    type: 'text',
+                    text: JSON.stringify({ filled: args.selector, value: args.value }),
+                }],
+        };
+    });
+    // ── wait_for ─────────────────────────────────────────────
+    srv.registerTool('wait_for', {
+        title: 'Wait for Element',
+        description: 'Wait for an element to appear on the page. Useful after navigation or async operations.',
+        inputSchema: schemas_1.waitForSchema,
+    }, async (args) => {
+        const page = (0, lifecycle_1.getPage)(args.page_id);
+        await page.waitForSelector(args.selector, {
+            timeout: args.timeout ?? 10_000,
+        });
+        return {
+            content: [{
+                    type: 'text',
+                    text: JSON.stringify({ found: args.selector }),
+                }],
+        };
+    });
+    // ── evaluate ─────────────────────────────────────────────
+    srv.registerTool('evaluate', {
+        title: 'Run JavaScript',
+        description: 'Evaluate a JavaScript expression in the page context. Returns the serialized result.',
+        inputSchema: schemas_1.evaluateSchema,
+    }, async (args) => {
+        const page = (0, lifecycle_1.getPage)(args.page_id);
+        const result = await page.evaluate(args.script);
+        return {
+            content: [{
+                    type: 'text',
+                    text: JSON.stringify({ result }),
+                }],
+        };
+    });
+    // ── list_pages ───────────────────────────────────────────
+    srv.registerTool('list_pages', {
+        title: 'List Open Pages',
+        description: 'List all open browser pages with their IDs, URLs, and titles.',
+        inputSchema: schemas_1.listPagesSchema,
+    }, async (_args) => {
+        const result = [];
+        for (const [id, page] of lifecycle_1.pages) {
+            result.push({
+                page_id: id,
+                url: page.url(),
+                title: await page.title(),
+            });
+        }
+        return {
+            content: [{
+                    type: 'text',
+                    text: JSON.stringify({ pages: result, count: result.length }),
+                }],
+        };
+    });
+    // ── close_page ───────────────────────────────────────────
+    srv.registerTool('close_page', {
+        title: 'Close Page',
+        description: 'Close a browser page by its ID.',
+        inputSchema: schemas_1.closePageSchema,
+    }, async (args) => {
+        const page = lifecycle_1.pages.get(args.page_id);
+        if (!page) {
+            return {
+                content: [{
+                        type: 'text',
+                        text: JSON.stringify({ error: `Page not found: ${args.page_id}` }),
+                    }],
+                isError: true,
+            };
+        }
+        await page.close();
+        lifecycle_1.pages.delete(args.page_id);
+        return {
+            content: [{
+                    type: 'text',
+                    text: JSON.stringify({ closed: args.page_id }),
+                }],
+        };
+    });
+}