mcp-accessibility-scanner 1.0.9 → 1.0.11

package/build/index.js

@@ -17,6 +17,62 @@ const server = new mcp_js_1.McpServer({
     name: "AccessibilityTools",
     version: "1.0.0",
 });
+class SessionManager {
+    constructor() {
+        this.sessions = new Map();
+        this.sessionTimeouts = new Map();
+        this.SESSION_TIMEOUT = 3 * 60 * 1000; // 3 minutes
+    }
+    createSession(sessionId_1, viewport_1) {
+        return __awaiter(this, arguments, void 0, function* (sessionId, viewport, shouldRunInHeadless = true) {
+            if (this.sessions.has(sessionId)) {
+                throw new Error(`Session ${sessionId} already exists`);
+            }
+            const scanner = new accessibilityChecker_1.AccessibilityScanner();
+            yield scanner.initialize(shouldRunInHeadless);
+            yield scanner.createContext(viewport);
+            yield scanner.createPage();
+            this.sessions.set(sessionId, scanner);
+            this.resetSessionTimeout(sessionId);
+            return scanner;
+        });
+    }
+    getSession(sessionId) {
+        const session = this.sessions.get(sessionId);
+        if (session) {
+            this.resetSessionTimeout(sessionId);
+        }
+        return session;
+    }
+    closeSession(sessionId) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const session = this.sessions.get(sessionId);
+            if (session) {
+                yield session.cleanup();
+                this.sessions.delete(sessionId);
+                const timeout = this.sessionTimeouts.get(sessionId);
+                if (timeout) {
+                    clearTimeout(timeout);
+                    this.sessionTimeouts.delete(sessionId);
+                }
+            }
+        });
+    }
+    listSessions() {
+        return Array.from(this.sessions.keys());
+    }
+    resetSessionTimeout(sessionId) {
+        const existingTimeout = this.sessionTimeouts.get(sessionId);
+        if (existingTimeout) {
+            clearTimeout(existingTimeout);
+        }
+        const timeout = setTimeout(() => {
+            this.closeSession(sessionId);
+        }, this.SESSION_TIMEOUT);
+        this.sessionTimeouts.set(sessionId, timeout);
+    }
+}
+const sessionManager = new SessionManager();
 const tagValues = [
     "wcag2a", "wcag2aa", "wcag2aaa", "wcag21a", "wcag21aa", "wcag21aaa",
     "wcag22a", "wcag22aa", "wcag22aaa", "section508", "cat.aria", "cat.color",
@@ -31,7 +87,7 @@ server.registerTool("accessibility-scan", {
         url: zod_1.z.string().url().describe("The public URL to scan for accessibility violations"),
         violationsTag: zod_1.z
             .array(zod_1.z.enum(tagValues))
-            .min(1) // Ensure the array is not empty
+            .min(1)
             .describe("An array of tags for violation types to check"),
         viewport: zod_1.z
             .object({
@@ -60,4 +116,843 @@ server.registerTool("accessibility-scan", {
         isError: false,
     };
 }));
+server.registerTool("click-element", {
+    title: "Click Element",
+    description: "Clicks on an element specified by a CSS selector on the current page.",
+    inputSchema: zod_1.z.object({
+        url: zod_1.z.string().url().describe("The public URL to navigate to"),
+        selector: zod_1.z.string().describe("CSS selector for the element to click"),
+        viewport: zod_1.z
+            .object({
+            width: zod_1.z.number().default(1920),
+            height: zod_1.z.number().default(1080),
+        })
+            .optional()
+            .describe("Optional viewport dimensions"),
+        shouldRunInHeadless: zod_1.z.boolean().default(true).describe("Whether to run the browser in headless mode"),
+    }).shape,
+}, (args) => __awaiter(void 0, void 0, void 0, function* () {
+    const { url, selector, viewport, shouldRunInHeadless } = args;
+    const scanner = new accessibilityChecker_1.AccessibilityScanner();
+    try {
+        yield scanner.initialize(shouldRunInHeadless);
+        yield scanner.createContext(viewport);
+        yield scanner.createPage();
+        yield scanner.navigateToUrl(url);
+        yield scanner.clickElement(selector);
+        const base64Screenshot = yield scanner.takeScreenshot();
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: JSON.stringify({
+                        message: `Successfully clicked element: ${selector}`,
+                        url,
+                        selector,
+                    }, null, 2),
+                },
+                {
+                    type: "image",
+                    data: base64Screenshot,
+                    mimeType: "image/png",
+                },
+            ],
+            isError: false,
+        };
+    }
+    catch (error) {
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: JSON.stringify({
+                        message: `Failed to click element: ${selector}`,
+                        error: error instanceof Error ? error.message : "Unknown error",
+                        url,
+                        selector,
+                    }, null, 2),
+                },
+            ],
+            isError: true,
+        };
+    }
+    finally {
+        yield scanner.cleanup();
+    }
+}));
+server.registerTool("type-text", {
+    title: "Type Text",
+    description: "Types text into an input field specified by a CSS selector.",
+    inputSchema: zod_1.z.object({
+        url: zod_1.z.string().url().describe("The public URL to navigate to"),
+        selector: zod_1.z.string().describe("CSS selector for the input field"),
+        text: zod_1.z.string().describe("Text to type into the input field"),
+        viewport: zod_1.z
+            .object({
+            width: zod_1.z.number().default(1920),
+            height: zod_1.z.number().default(1080),
+        })
+            .optional()
+            .describe("Optional viewport dimensions"),
+        shouldRunInHeadless: zod_1.z.boolean().default(true).describe("Whether to run the browser in headless mode"),
+    }).shape,
+}, (args) => __awaiter(void 0, void 0, void 0, function* () {
+    const { url, selector, text, viewport, shouldRunInHeadless } = args;
+    const scanner = new accessibilityChecker_1.AccessibilityScanner();
+    try {
+        yield scanner.initialize(shouldRunInHeadless);
+        yield scanner.createContext(viewport);
+        yield scanner.createPage();
+        yield scanner.navigateToUrl(url);
+        yield scanner.typeText(selector, text);
+        const base64Screenshot = yield scanner.takeScreenshot();
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: JSON.stringify({
+                        message: `Successfully typed text into element: ${selector}`,
+                        url,
+                        selector,
+                        text,
+                    }, null, 2),
+                },
+                {
+                    type: "image",
+                    data: base64Screenshot,
+                    mimeType: "image/png",
+                },
+            ],
+            isError: false,
+        };
+    }
+    catch (error) {
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: JSON.stringify({
+                        message: `Failed to type text into element: ${selector}`,
+                        error: error instanceof Error ? error.message : "Unknown error",
+                        url,
+                        selector,
+                        text,
+                    }, null, 2),
+                },
+            ],
+            isError: true,
+        };
+    }
+    finally {
+        yield scanner.cleanup();
+    }
+}));
+server.registerTool("create-session", {
+    title: "Create Browser Session",
+    description: "Creates a new persistent browser session that can be used for multiple operations.",
+    inputSchema: zod_1.z.object({
+        sessionId: zod_1.z.string().describe("Unique identifier for the session"),
+        viewport: zod_1.z
+            .object({
+            width: zod_1.z.number().default(1920),
+            height: zod_1.z.number().default(1080),
+        })
+            .optional()
+            .describe("Optional viewport dimensions"),
+        shouldRunInHeadless: zod_1.z.boolean().default(true).describe("Whether to run the browser in headless mode"),
+    }).shape,
+}, (args) => __awaiter(void 0, void 0, void 0, function* () {
+    const { sessionId, viewport, shouldRunInHeadless } = args;
+    try {
+        yield sessionManager.createSession(sessionId, viewport, shouldRunInHeadless);
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: JSON.stringify({
+                        message: `Session ${sessionId} created successfully`,
+                        sessionId,
+                        viewport: viewport || { width: 1920, height: 1080 },
+                        headless: shouldRunInHeadless,
+                    }, null, 2),
+                },
+            ],
+            isError: false,
+        };
+    }
+    catch (error) {
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: JSON.stringify({
+                        message: `Failed to create session: ${sessionId}`,
+                        error: error instanceof Error ? error.message : "Unknown error",
+                        sessionId,
+                    }, null, 2),
+                },
+            ],
+            isError: true,
+        };
+    }
+}));
+server.registerTool("navigate-session", {
+    title: "Navigate Session",
+    description: "Navigates to a URL in an existing browser session.",
+    inputSchema: zod_1.z.object({
+        sessionId: zod_1.z.string().describe("Session identifier"),
+        url: zod_1.z.string().url().describe("The URL to navigate to"),
+    }).shape,
+}, (args) => __awaiter(void 0, void 0, void 0, function* () {
+    const { sessionId, url } = args;
+    try {
+        const session = sessionManager.getSession(sessionId);
+        if (!session) {
+            throw new Error(`Session ${sessionId} not found`);
+        }
+        yield session.navigateToUrl(url);
+        const base64Screenshot = yield session.takeScreenshot();
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: JSON.stringify({
+                        message: `Successfully navigated to ${url}`,
+                        sessionId,
+                        url,
+                    }, null, 2),
+                },
+                {
+                    type: "image",
+                    data: base64Screenshot,
+                    mimeType: "image/png",
+                },
+            ],
+            isError: false,
+        };
+    }
+    catch (error) {
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: JSON.stringify({
+                        message: `Failed to navigate in session: ${sessionId}`,
+                        error: error instanceof Error ? error.message : "Unknown error",
+                        sessionId,
+                        url,
+                    }, null, 2),
+                },
+            ],
+            isError: true,
+        };
+    }
+}));
+server.registerTool("click-session", {
+    title: "Click Element in Session",
+    description: "Clicks on an element in an existing browser session.",
+    inputSchema: zod_1.z.object({
+        sessionId: zod_1.z.string().describe("Session identifier"),
+        selector: zod_1.z.string().describe("CSS selector for the element to click"),
+    }).shape,
+}, (args) => __awaiter(void 0, void 0, void 0, function* () {
+    const { sessionId, selector } = args;
+    try {
+        const session = sessionManager.getSession(sessionId);
+        if (!session) {
+            throw new Error(`Session ${sessionId} not found`);
+        }
+        yield session.clickElement(selector);
+        const base64Screenshot = yield session.takeScreenshot();
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: JSON.stringify({
+                        message: `Successfully clicked element: ${selector}`,
+                        sessionId,
+                        selector,
+                    }, null, 2),
+                },
+                {
+                    type: "image",
+                    data: base64Screenshot,
+                    mimeType: "image/png",
+                },
+            ],
+            isError: false,
+        };
+    }
+    catch (error) {
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: JSON.stringify({
+                        message: `Failed to click element in session: ${sessionId}`,
+                        error: error instanceof Error ? error.message : "Unknown error",
+                        sessionId,
+                        selector,
+                    }, null, 2),
+                },
+            ],
+            isError: true,
+        };
+    }
+}));
+server.registerTool("type-session", {
+    title: "Type Text in Session",
+    description: "Types text into an input field in an existing browser session.",
+    inputSchema: zod_1.z.object({
+        sessionId: zod_1.z.string().describe("Session identifier"),
+        selector: zod_1.z.string().describe("CSS selector for the input field"),
+        text: zod_1.z.string().describe("Text to type into the input field"),
+    }).shape,
+}, (args) => __awaiter(void 0, void 0, void 0, function* () {
+    const { sessionId, selector, text } = args;
+    try {
+        const session = sessionManager.getSession(sessionId);
+        if (!session) {
+            throw new Error(`Session ${sessionId} not found`);
+        }
+        yield session.typeText(selector, text);
+        const base64Screenshot = yield session.takeScreenshot();
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: JSON.stringify({
+                        message: `Successfully typed text into element: ${selector}`,
+                        sessionId,
+                        selector,
+                        text,
+                    }, null, 2),
+                },
+                {
+                    type: "image",
+                    data: base64Screenshot,
+                    mimeType: "image/png",
+                },
+            ],
+            isError: false,
+        };
+    }
+    catch (error) {
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: JSON.stringify({
+                        message: `Failed to type text in session: ${sessionId}`,
+                        error: error instanceof Error ? error.message : "Unknown error",
+                        sessionId,
+                        selector,
+                        text,
+                    }, null, 2),
+                },
+            ],
+            isError: true,
+        };
+    }
+}));
+server.registerTool("scan-session", {
+    title: "Scan Session for Accessibility",
+    description: "Runs an accessibility scan on the current page in an existing browser session.",
+    inputSchema: zod_1.z.object({
+        sessionId: zod_1.z.string().describe("Session identifier"),
+        violationsTag: zod_1.z
+            .array(zod_1.z.enum(tagValues))
+            .min(1)
+            .describe("An array of tags for violation types to check"),
+    }).shape,
+}, (args) => __awaiter(void 0, void 0, void 0, function* () {
+    const { sessionId, violationsTag } = args;
+    try {
+        const session = sessionManager.getSession(sessionId);
+        if (!session) {
+            throw new Error(`Session ${sessionId} not found`);
+        }
+        const { report, base64Screenshot } = yield session.scanViolations(violationsTag);
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: JSON.stringify({
+                        message: "Accessibility scan completed",
+                        sessionId,
+                        report,
+                    }, null, 2),
+                },
+                {
+                    type: "image",
+                    data: base64Screenshot,
+                    mimeType: "image/png",
+                },
+            ],
+            isError: false,
+        };
+    }
+    catch (error) {
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: JSON.stringify({
+                        message: `Failed to scan session: ${sessionId}`,
+                        error: error instanceof Error ? error.message : "Unknown error",
+                        sessionId,
+                    }, null, 2),
+                },
+            ],
+            isError: true,
+        };
+    }
+}));
+server.registerTool("close-session", {
+    title: "Close Browser Session",
+    description: "Closes an existing browser session.",
+    inputSchema: zod_1.z.object({
+        sessionId: zod_1.z.string().describe("Session identifier"),
+    }).shape,
+}, (args) => __awaiter(void 0, void 0, void 0, function* () {
+    const { sessionId } = args;
+    try {
+        yield sessionManager.closeSession(sessionId);
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: JSON.stringify({
+                        message: `Session ${sessionId} closed successfully`,
+                        sessionId,
+                    }, null, 2),
+                },
+            ],
+            isError: false,
+        };
+    }
+    catch (error) {
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: JSON.stringify({
+                        message: `Failed to close session: ${sessionId}`,
+                        error: error instanceof Error ? error.message : "Unknown error",
+                        sessionId,
+                    }, null, 2),
+                },
+            ],
+            isError: true,
+        };
+    }
+}));
+server.registerTool("list-sessions", {
+    title: "List Browser Sessions",
+    description: "Lists all active browser sessions.",
+    inputSchema: zod_1.z.object({}).shape,
+}, () => __awaiter(void 0, void 0, void 0, function* () {
+    try {
+        const sessions = sessionManager.listSessions();
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: JSON.stringify({
+                        message: "Active browser sessions",
+                        sessions,
+                        count: sessions.length,
+                    }, null, 2),
+                },
+            ],
+            isError: false,
+        };
+    }
+    catch (error) {
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: JSON.stringify({
+                        message: "Failed to list sessions",
+                        error: error instanceof Error ? error.message : "Unknown error",
+                    }, null, 2),
+                },
+            ],
+            isError: true,
+        };
+    }
+}));
+server.registerTool("click-element-by-text", {
+    title: "Click Element by Text",
+    description: "Clicks on an element by its visible text content. More reliable than CSS selectors for dynamic content.",
+    inputSchema: zod_1.z.object({
+        url: zod_1.z.string().url().describe("The public URL to navigate to"),
+        text: zod_1.z.string().describe("The visible text of the element to click"),
+        elementType: zod_1.z.string().optional().describe("Optional element type (e.g., 'button', 'a', 'div')"),
+        viewport: zod_1.z
+            .object({
+            width: zod_1.z.number().default(1920),
+            height: zod_1.z.number().default(1080),
+        })
+            .optional()
+            .describe("Optional viewport dimensions"),
+        shouldRunInHeadless: zod_1.z.boolean().default(true).describe("Whether to run the browser in headless mode"),
+    }).shape,
+}, (args) => __awaiter(void 0, void 0, void 0, function* () {
+    const { url, text, elementType, viewport, shouldRunInHeadless } = args;
+    const scanner = new accessibilityChecker_1.AccessibilityScanner();
+    try {
+        yield scanner.initialize(shouldRunInHeadless);
+        yield scanner.createContext(viewport);
+        yield scanner.createPage();
+        yield scanner.navigateToUrl(url);
+        yield scanner.clickElementByText(text, elementType);
+        const base64Screenshot = yield scanner.takeScreenshot();
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: JSON.stringify({
+                        message: `Successfully clicked element with text: "${text}"`,
+                        url,
+                        text,
+                        elementType,
+                    }, null, 2),
+                },
+                {
+                    type: "image",
+                    data: base64Screenshot,
+                    mimeType: "image/png",
+                },
+            ],
+            isError: false,
+        };
+    }
+    catch (error) {
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: JSON.stringify({
+                        message: `Failed to click element with text: "${text}"`,
+                        error: error instanceof Error ? error.message : "Unknown error",
+                        url,
+                        text,
+                    }, null, 2),
+                },
+            ],
+            isError: true,
+        };
+    }
+    finally {
+        yield scanner.cleanup();
+    }
+}));
+server.registerTool("type-text-by-label", {
+    title: "Type Text by Label",
+    description: "Types text into an input field identified by its label text. More intuitive than CSS selectors.",
+    inputSchema: zod_1.z.object({
+        url: zod_1.z.string().url().describe("The public URL to navigate to"),
+        labelText: zod_1.z.string().describe("The label text of the input field"),
+        text: zod_1.z.string().describe("Text to type into the input field"),
+        viewport: zod_1.z
+            .object({
+            width: zod_1.z.number().default(1920),
+            height: zod_1.z.number().default(1080),
+        })
+            .optional()
+            .describe("Optional viewport dimensions"),
+        shouldRunInHeadless: zod_1.z.boolean().default(true).describe("Whether to run the browser in headless mode"),
+    }).shape,
+}, (args) => __awaiter(void 0, void 0, void 0, function* () {
+    const { url, labelText, text, viewport, shouldRunInHeadless } = args;
+    const scanner = new accessibilityChecker_1.AccessibilityScanner();
+    try {
+        yield scanner.initialize(shouldRunInHeadless);
+        yield scanner.createContext(viewport);
+        yield scanner.createPage();
+        yield scanner.navigateToUrl(url);
+        yield scanner.typeTextByLabel(labelText, text);
+        const base64Screenshot = yield scanner.takeScreenshot();
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: JSON.stringify({
+                        message: `Successfully typed text into field with label: "${labelText}"`,
+                        url,
+                        labelText,
+                        text,
+                    }, null, 2),
+                },
+                {
+                    type: "image",
+                    data: base64Screenshot,
+                    mimeType: "image/png",
+                },
+            ],
+            isError: false,
+        };
+    }
+    catch (error) {
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: JSON.stringify({
+                        message: `Failed to type text into field with label: "${labelText}"`,
+                        error: error instanceof Error ? error.message : "Unknown error",
+                        url,
+                        labelText,
+                        text,
+                    }, null, 2),
+                },
+            ],
+            isError: true,
+        };
+    }
+    finally {
+        yield scanner.cleanup();
+    }
+}));
+server.registerTool("analyze-page", {
+    title: "Analyze Page",
+    description: "Analyzes the current page and returns all interactive elements (buttons, links, inputs) to prevent guessing.",
+    inputSchema: zod_1.z.object({
+        url: zod_1.z.string().url().describe("The public URL to analyze"),
+        viewport: zod_1.z
+            .object({
+            width: zod_1.z.number().default(1920),
+            height: zod_1.z.number().default(1080),
+        })
+            .optional()
+            .describe("Optional viewport dimensions"),
+        shouldRunInHeadless: zod_1.z.boolean().default(true).describe("Whether to run the browser in headless mode"),
+    }).shape,
+}, (args) => __awaiter(void 0, void 0, void 0, function* () {
+    const { url, viewport, shouldRunInHeadless } = args;
+    const scanner = new accessibilityChecker_1.AccessibilityScanner();
+    try {
+        yield scanner.initialize(shouldRunInHeadless);
+        yield scanner.createContext(viewport);
+        yield scanner.createPage();
+        yield scanner.navigateToUrl(url);
+        const analysis = yield scanner.analyzePage();
+        const base64Screenshot = yield scanner.takeScreenshot();
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: JSON.stringify({
+                        message: "Page analysis completed",
+                        url,
+                        elements: {
+                            buttons: analysis.buttons,
+                            links: analysis.links,
+                            inputs: analysis.inputs,
+                            totals: {
+                                buttons: analysis.buttons.length,
+                                links: analysis.links.length,
+                                inputs: analysis.inputs.length,
+                            },
+                        },
+                    }, null, 2),
+                },
+                {
+                    type: "image",
+                    data: base64Screenshot,
+                    mimeType: "image/png",
+                },
+            ],
+            isError: false,
+        };
+    }
+    catch (error) {
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: JSON.stringify({
+                        message: "Failed to analyze page",
+                        error: error instanceof Error ? error.message : "Unknown error",
+                        url,
+                    }, null, 2),
+                },
+            ],
+            isError: true,
+        };
+    }
+    finally {
+        yield scanner.cleanup();
+    }
+}));
+server.registerTool("click-session-by-text", {
+    title: "Click Element by Text in Session",
+    description: "Clicks on an element by its visible text in an existing browser session.",
+    inputSchema: zod_1.z.object({
+        sessionId: zod_1.z.string().describe("Session identifier"),
+        text: zod_1.z.string().describe("The visible text of the element to click"),
+        elementType: zod_1.z.string().optional().describe("Optional element type (e.g., 'button', 'a', 'div')"),
+    }).shape,
+}, (args) => __awaiter(void 0, void 0, void 0, function* () {
+    const { sessionId, text, elementType } = args;
+    try {
+        const session = sessionManager.getSession(sessionId);
+        if (!session) {
+            throw new Error(`Session ${sessionId} not found`);
+        }
+        yield session.clickElementByText(text, elementType);
+        const base64Screenshot = yield session.takeScreenshot();
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: JSON.stringify({
+                        message: `Successfully clicked element with text: "${text}"`,
+                        sessionId,
+                        text,
+                        elementType,
+                    }, null, 2),
+                },
+                {
+                    type: "image",
+                    data: base64Screenshot,
+                    mimeType: "image/png",
+                },
+            ],
+            isError: false,
+        };
+    }
+    catch (error) {
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: JSON.stringify({
+                        message: `Failed to click element with text in session: ${sessionId}`,
+                        error: error instanceof Error ? error.message : "Unknown error",
+                        sessionId,
+                        text,
+                    }, null, 2),
+                },
+            ],
+            isError: true,
+        };
+    }
+}));
+server.registerTool("type-session-by-label", {
+    title: "Type Text by Label in Session",
+    description: "Types text into an input field identified by its label in an existing browser session.",
+    inputSchema: zod_1.z.object({
+        sessionId: zod_1.z.string().describe("Session identifier"),
+        labelText: zod_1.z.string().describe("The label text of the input field"),
+        text: zod_1.z.string().describe("Text to type into the input field"),
+    }).shape,
+}, (args) => __awaiter(void 0, void 0, void 0, function* () {
+    const { sessionId, labelText, text } = args;
+    try {
+        const session = sessionManager.getSession(sessionId);
+        if (!session) {
+            throw new Error(`Session ${sessionId} not found`);
+        }
+        yield session.typeTextByLabel(labelText, text);
+        const base64Screenshot = yield session.takeScreenshot();
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: JSON.stringify({
+                        message: `Successfully typed text into field with label: "${labelText}"`,
+                        sessionId,
+                        labelText,
+                        text,
+                    }, null, 2),
+                },
+                {
+                    type: "image",
+                    data: base64Screenshot,
+                    mimeType: "image/png",
+                },
+            ],
+            isError: false,
+        };
+    }
+    catch (error) {
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: JSON.stringify({
+                        message: `Failed to type text by label in session: ${sessionId}`,
+                        error: error instanceof Error ? error.message : "Unknown error",
+                        sessionId,
+                        labelText,
+                        text,
+                    }, null, 2),
+                },
+            ],
+            isError: true,
+        };
+    }
+}));
+server.registerTool("analyze-session", {
+    title: "Analyze Page in Session",
+    description: "Analyzes the current page in an existing browser session.",
+    inputSchema: zod_1.z.object({
+        sessionId: zod_1.z.string().describe("Session identifier"),
+    }).shape,
+}, (args) => __awaiter(void 0, void 0, void 0, function* () {
+    const { sessionId } = args;
+    try {
+        const session = sessionManager.getSession(sessionId);
+        if (!session) {
+            throw new Error(`Session ${sessionId} not found`);
+        }
+        const analysis = yield session.analyzePage();
+        const base64Screenshot = yield session.takeScreenshot();
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: JSON.stringify({
+                        message: "Page analysis completed",
+                        sessionId,
+                        elements: {
+                            buttons: analysis.buttons,
+                            links: analysis.links,
+                            inputs: analysis.inputs,
+                            totals: {
+                                buttons: analysis.buttons.length,
+                                links: analysis.links.length,
+                                inputs: analysis.inputs.length,
+                            },
+                        },
+                    }, null, 2),
+                },
+                {
+                    type: "image",
+                    data: base64Screenshot,
+                    mimeType: "image/png",
+                },
+            ],
+            isError: false,
+        };
+    }
+    catch (error) {
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: JSON.stringify({
+                        message: `Failed to analyze page in session: ${sessionId}`,
+                        error: error instanceof Error ? error.message : "Unknown error",
+                        sessionId,
+                    }, null, 2),
+                },
+            ],
+            isError: true,
+        };
+    }
+}));
 exports.default = server;