screenpipe-mcp 0.5.0 → 0.7.0

package/dist/index.js

@@ -54,11 +54,6 @@ function getCurrentDateInfo() {
         }),
     };
 }
-// Detect OS
-const CURRENT_OS = process.platform;
-const IS_MACOS = CURRENT_OS === "darwin";
-const IS_WINDOWS = CURRENT_OS === "win32";
-const IS_LINUX = CURRENT_OS === "linux";
 // Parse command line arguments
 const args = process.argv.slice(2);
 let port = 3030;
@@ -71,7 +66,7 @@ const SCREENPIPE_API = `http://localhost:${port}`;
 // Initialize server
 const server = new index_js_1.Server({
     name: "screenpipe",
-    version: "0.5.0",
+    version: "0.7.0",
 }, {
     capabilities: {
         tools: {},
@@ -101,7 +96,7 @@ const BASE_TOOLS = [
                 content_type: {
                     type: "string",
                     enum: ["all", "ocr", "audio", "ui"],
-                    description: "Content type filter. Default: 'all'",
+                    description: "Content type filter: 'ocr' (screen text), 'audio' (transcriptions), 'ui' (legacy UI monitoring), 'all'. Default: 'all'. For keyboard/mouse/accessibility events, use search-ui-events tool instead.",
                     default: "all",
                 },
                 limit: {
@@ -145,55 +140,15 @@ const BASE_TOOLS = [
                     description: "Include base64 screenshots (OCR only). Default: false",
                     default: false,
                 },
-            },
-        },
-    },
-    {
-        name: "pixel-control",
-        description: "Control mouse and keyboard at the pixel level. This is a cross-platform tool that works on all operating systems. " +
-            "Use this to type text, press keys, move the mouse, and click buttons.",
-        annotations: {
-            title: "Pixel Control",
-            destructiveHint: true,
-        },
-        inputSchema: {
-            type: "object",
-            properties: {
-                action_type: {
+                speaker_ids: {
                     type: "string",
-                    enum: ["WriteText", "KeyPress", "MouseMove", "MouseClick"],
-                    description: "Type of input action to perform",
+                    description: "Comma-separated speaker IDs to filter audio results (e.g., '1,2,3')",
                 },
-                data: {
-                    oneOf: [
-                        {
-                            type: "string",
-                            description: "Text to type or key to press (for WriteText and KeyPress)",
-                        },
-                        {
-                            type: "object",
-                            properties: {
-                                x: {
-                                    type: "integer",
-                                    description: "X coordinate for mouse movement",
-                                },
-                                y: {
-                                    type: "integer",
-                                    description: "Y coordinate for mouse movement",
-                                },
-                            },
-                            description: "Coordinates for MouseMove",
-                        },
-                        {
-                            type: "string",
-                            enum: ["left", "right", "middle"],
-                            description: "Button to click for MouseClick",
-                        },
-                    ],
-                    description: "Action-specific data",
+                speaker_name: {
+                    type: "string",
+                    description: "Filter audio by speaker name (case-insensitive partial match)",
                 },
             },
-            required: ["action_type", "data"],
         },
     },
     {
@@ -230,230 +185,88 @@ const BASE_TOOLS = [
             required: ["start_time", "end_time"],
         },
     },
-];
-const MACOS_TOOLS = [
     {
-        name: "find-elements",
-        description: "Find UI elements with a specific role in an application. " +
-            "This tool is especially useful for identifying interactive elements. " +
-            "\n\nMacOS Accessibility Roles Guide:\n" +
-            "- Basic roles: 'button', 'textfield', 'checkbox', 'menu', 'list'\n" +
-            "- MacOS specific roles: 'AXButton', 'AXTextField', 'AXCheckBox', 'AXMenu', etc.\n" +
-            "- Text inputs can be: 'AXTextField', 'AXTextArea', 'AXComboBox', 'AXSearchField'\n" +
-            "- Clickable items: 'AXButton', 'AXMenuItem', 'AXMenuBarItem', 'AXImage', 'AXStaticText'\n" +
-            "- Web content may use: 'AXWebArea', 'AXLink', 'AXHeading', 'AXRadioButton'\n\n" +
-            "Use MacOS Accessibility Inspector app to identify the exact roles in your target application.",
+        name: "search-ui-events",
+        description: "Search UI input events captured via accessibility APIs (macOS). " +
+            "This is the third modality alongside vision (OCR) and audio. " +
+            "Captures: mouse clicks, keyboard text input, scroll events, app/window switches, clipboard operations. " +
+            "Events include app context, element info (accessibility labels), and precise timestamps. " +
+            "Great for understanding user workflow, what was typed, clicked, or copied.",
         annotations: {
-            title: "Find Elements",
+            title: "Search UI Events (Accessibility)",
             readOnlyHint: true,
         },
         inputSchema: {
             type: "object",
             properties: {
-                app: {
-                    type: "string",
-                    description: "The name of the application (e.g., 'Chrome', 'Finder', 'Terminal')",
-                },
-                window: {
-                    type: "string",
-                    description: "The window name or title (optional)",
-                },
-                role: {
-                    type: "string",
-                    description: "The role to search for (e.g., 'button', 'textfield', 'AXButton', 'AXTextField'). For best results, use MacOS AX prefixed roles.",
-                },
-                max_results: {
-                    type: "integer",
-                    description: "Maximum number of elements to return",
-                    default: 10,
-                },
-                max_depth: {
-                    type: "integer",
-                    description: "Maximum depth of element tree to search",
-                },
-                use_background_apps: {
-                    type: "boolean",
-                    description: "Whether to look in background apps",
-                    default: true,
-                },
-                activate_app: {
-                    type: "boolean",
-                    description: "Whether to activate the app before searching",
-                    default: true,
-                },
-            },
-            required: ["app", "role"],
-        },
-    },
-    {
-        name: "click-element",
-        description: "Click an element in an application using its id (MacOS only)",
-        annotations: {
-            title: "Click Element",
-            destructiveHint: true,
-        },
-        inputSchema: {
-            type: "object",
-            properties: {
-                app: {
-                    type: "string",
-                    description: "The name of the application",
-                },
-                window: {
-                    type: "string",
-                    description: "The window name (optional)",
-                },
-                id: {
-                    type: "string",
-                    description: "The id of the element to click",
-                },
-                use_background_apps: {
-                    type: "boolean",
-                    description: "Whether to look in background apps",
-                    default: true,
-                },
-                activate_app: {
-                    type: "boolean",
-                    description: "Whether to activate the app before clicking",
-                    default: true,
-                },
-            },
-            required: ["app", "id"],
-        },
-    },
-    {
-        name: "fill-element",
-        description: "Type text into an element in an application (MacOS only)",
-        annotations: {
-            title: "Fill Element",
-            destructiveHint: true,
-        },
-        inputSchema: {
-            type: "object",
-            properties: {
-                app: {
-                    type: "string",
-                    description: "The name of the application",
-                },
-                window: {
-                    type: "string",
-                    description: "The window name (optional)",
-                },
-                id: {
+                q: {
                     type: "string",
-                    description: "The id of the element to fill",
+                    description: "Search query for text content, app name, window title. Optional - omit to return recent events.",
                 },
-                text: {
+                event_type: {
                     type: "string",
-                    description: "The text to type into the element",
+                    enum: ["click", "text", "scroll", "key", "app_switch", "window_focus", "clipboard"],
+                    description: "Filter by event type. 'text' = aggregated keyboard input, 'click' = mouse clicks with element context, 'app_switch'/'window_focus' = app usage tracking, 'clipboard' = copy/paste events.",
                 },
-                use_background_apps: {
-                    type: "boolean",
-                    description: "Whether to look in background apps",
-                    default: true,
-                },
-                activate_app: {
-                    type: "boolean",
-                    description: "Whether to activate the app before typing",
-                    default: true,
-                },
-            },
-            required: ["app", "id", "text"],
-        },
-    },
-    {
-        name: "scroll-element",
-        description: "Scroll an element in a specific direction (MacOS only)",
-        annotations: {
-            title: "Scroll Element",
-            destructiveHint: true,
-        },
-        inputSchema: {
-            type: "object",
-            properties: {
-                app: {
+                app_name: {
                     type: "string",
-                    description: "The name of the application",
+                    description: "Filter by application name (e.g., 'Google Chrome', 'Slack', 'Code')",
                 },
-                window: {
+                window_name: {
                     type: "string",
-                    description: "The window name (optional)",
+                    description: "Filter by window title",
                 },
-                id: {
+                start_time: {
                     type: "string",
-                    description: "The id of the element to scroll",
+                    format: "date-time",
+                    description: "ISO 8601 UTC start time (e.g., 2024-01-15T10:00:00Z)",
                 },
-                direction: {
+                end_time: {
                     type: "string",
-                    enum: ["up", "down", "left", "right"],
-                    description: "The direction to scroll",
+                    format: "date-time",
+                    description: "ISO 8601 UTC end time (e.g., 2024-01-15T18:00:00Z)",
                 },
-                amount: {
+                limit: {
                     type: "integer",
-                    description: "The amount to scroll in pixels",
-                },
-                use_background_apps: {
-                    type: "boolean",
-                    description: "Whether to look in background apps",
-                    default: true,
-                },
-                activate_app: {
-                    type: "boolean",
-                    description: "Whether to activate the app before scrolling",
-                    default: true,
+                    description: "Max results. Default: 50",
+                    default: 50,
                 },
-            },
-            required: ["app", "id", "direction", "amount"],
-        },
-    },
-    {
-        name: "open-application",
-        description: "Open an application by name",
-        annotations: {
-            title: "Open Application",
-            destructiveHint: true,
-        },
-        inputSchema: {
-            type: "object",
-            properties: {
-                app_name: {
-                    type: "string",
-                    description: "The name of the application to open",
+                offset: {
+                    type: "integer",
+                    description: "Skip N results for pagination. Default: 0",
+                    default: 0,
                 },
             },
-            required: ["app_name"],
         },
     },
     {
-        name: "open-url",
-        description: "Open a URL in a browser",
+        name: "get-ui-event-stats",
+        description: "Get aggregated statistics of UI events by app and event type. " +
+            "Useful for understanding app usage patterns, productivity analysis, or finding which apps were used most.",
         annotations: {
-            title: "Open URL",
-            destructiveHint: true,
+            title: "UI Event Statistics",
+            readOnlyHint: true,
         },
         inputSchema: {
             type: "object",
             properties: {
-                url: {
+                start_time: {
                     type: "string",
-                    description: "The URL to open",
+                    format: "date-time",
+                    description: "ISO 8601 UTC start time for stats period",
                 },
-                browser: {
+                end_time: {
                     type: "string",
-                    description: "The browser to use (optional)",
+                    format: "date-time",
+                    description: "ISO 8601 UTC end time for stats period",
                 },
             },
-            required: ["url"],
         },
     },
 ];
 // List tools handler
 server.setRequestHandler(types_js_1.ListToolsRequestSchema, async () => {
-    const tools = [...BASE_TOOLS];
-    if (IS_MACOS) {
-        tools.push(...MACOS_TOOLS);
-    }
-    return { tools };
+    return { tools: BASE_TOOLS };
 });
 // MCP Resources - provide dynamic context data
 const RESOURCES = [
@@ -517,18 +330,20 @@ server.setRequestHandler(types_js_1.ReadResourceRequestSchema, async (request) =
                         mimeType: "text/markdown",
                         text: `# Screenpipe Search Guide
 
+## Three Data Modalities
+
+Screenpipe captures three types of data:
+1. **Vision (OCR)** - Screen text from screenshots
+2. **Audio** - Transcribed speech from microphone/system audio
+3. **UI Events (Accessibility)** - Keyboard input, mouse clicks, app switches, clipboard (macOS)
+
 ## Quick Start
 - **Get recent activity**: Call search-content with no parameters
 - **Search text**: \`{"q": "search term", "content_type": "ocr"}\`
-- **Time filter**: Use start_time/end_time with ISO 8601 UTC timestamps
+- **Get keyboard input**: Use search-ui-events with \`event_type: "text"\`
+- **Track app usage**: Use get-ui-event-stats for aggregated data
 
-## Content Types
-- \`ocr\`: Screen text (what you see)
-- \`audio\`: Transcribed speech
-- \`ui\`: UI element interactions
-- \`all\`: Everything (default)
-
-## Key Parameters
+## search-content (Vision + Audio)
 | Parameter | Description | Default |
 |-----------|-------------|---------|
 | q | Search query | (none - returns all) |
@@ -539,11 +354,27 @@ server.setRequestHandler(types_js_1.ReadResourceRequestSchema, async (request) =
 | app_name | Filter by app | (no filter) |
 | include_frames | Include screenshots | false |
 
+## search-ui-events (Accessibility Data)
+| Parameter | Description | Default |
+|-----------|-------------|---------|
+| q | Search text content, app, window | (none) |
+| event_type | click/text/scroll/key/app_switch/window_focus/clipboard | (all types) |
+| app_name | Filter by application | (no filter) |
+| limit | Max results | 50 |
+
+### Event Types
+- \`text\`: Aggregated keyboard input (what was typed)
+- \`click\`: Mouse clicks with element context (accessibility labels)
+- \`app_switch\`: When user switched applications
+- \`window_focus\`: When window focus changed
+- \`clipboard\`: Copy/paste operations
+- \`scroll\`: Scroll events with delta values
+
 ## Tips
 1. Read screenpipe://context first to get current timestamps
-2. Omit \`q\` to get all content (useful for "what was I doing?")
-3. Use \`limit: 50-100\` for comprehensive searches
-4. Combine app_name + time filters for focused results`,
+2. Use search-ui-events for "what did I type?" queries
+3. Use get-ui-event-stats to understand app usage patterns
+4. Combine search-content (what was on screen) with search-ui-events (what was done)`,
                     },
                 ],
             };
@@ -731,25 +562,6 @@ server.setRequestHandler(types_js_1.CallToolRequestSchema, async (request) => {
     if (!args) {
         throw new Error("Missing arguments");
     }
-    // Check if the tool is MacOS-only and we're not on MacOS
-    const macosOnlyTools = [
-        "click-element",
-        "fill-element",
-        "find-elements",
-        "scroll-element",
-        "open-application",
-        "open-url",
-    ];
-    if (macosOnlyTools.includes(name) && !IS_MACOS) {
-        return {
-            content: [
-                {
-                    type: "text",
-                    text: `The '${name}' tool is only available on MacOS. Current platform: ${CURRENT_OS}`,
-                },
-            ],
-        };
-    }
     try {
         switch (name) {
             case "search-content": {
@@ -821,47 +633,6 @@ server.setRequestHandler(types_js_1.CallToolRequestSchema, async (request) => {
                 }
                 return { content: contentItems };
             }
-            case "pixel-control": {
-                const action = {
-                    type: args.action_type,
-                    data: args.data,
-                };
-                const response = await fetchAPI("/experimental/operator/pixel", {
-                    method: "POST",
-                    body: JSON.stringify({ action }),
-                });
-                if (!response.ok) {
-                    throw new Error(`HTTP error: ${response.status}`);
-                }
-                const data = await response.json();
-                if (!data.success) {
-                    return {
-                        content: [
-                            {
-                                type: "text",
-                                text: `Failed to perform input control: ${data.error || "unknown error"}`,
-                            },
-                        ],
-                    };
-                }
-                let resultText = "Successfully performed input control action";
-                if (args.action_type === "WriteText") {
-                    resultText = `Successfully typed text: '${args.data}'`;
-                }
-                else if (args.action_type === "KeyPress") {
-                    resultText = `Successfully pressed key: '${args.data}'`;
-                }
-                else if (args.action_type === "MouseMove") {
-                    const coords = args.data;
-                    resultText = `Successfully moved mouse to coordinates: x=${coords.x}, y=${coords.y}`;
-                }
-                else if (args.action_type === "MouseClick") {
-                    resultText = `Successfully clicked ${args.data} mouse button`;
-                }
-                return {
-                    content: [{ type: "text", text: resultText }],
-                };
-            }
             case "export-video": {
                 const startTime = args.start_time;
                 const endTime = args.end_time;
@@ -925,7 +696,8 @@ server.setRequestHandler(types_js_1.CallToolRequestSchema, async (request) => {
                 // Sort frame IDs
                 frameIds.sort((a, b) => a - b);
                 // Step 2: Connect to WebSocket and export video
-                const wsUrl = `ws://localhost:${port}/frames/export?frame_ids=${frameIds.join(",")}&fps=${fps}`;
+                // Send frame_ids in message body to avoid URL length limits
+                const wsUrl = `ws://localhost:${port}/frames/export?fps=${fps}`;
                 const exportResult = await new Promise((resolve) => {
                     const ws = new ws_1.WebSocket(wsUrl);
                     let resolved = false;
@@ -936,6 +708,10 @@ server.setRequestHandler(types_js_1.CallToolRequestSchema, async (request) => {
                             resolve({ success: false, error: "Export timed out after 5 minutes" });
                         }
                     }, 5 * 60 * 1000); // 5 minute timeout
+                    ws.on("open", () => {
+                        // Send frame_ids in message body to avoid URL length limits
+                        ws.send(JSON.stringify({ frame_ids: frameIds }));
+                    });
                     ws.on("error", (error) => {
                         if (!resolved) {
                             resolved = true;
@@ -1007,226 +783,119 @@ server.setRequestHandler(types_js_1.CallToolRequestSchema, async (request) => {
                     };
                 }
             }
-            case "click-element": {
-                const selector = {
-                    app_name: args.app,
-                    window_name: args.window,
-                    locator: `#${args.id}`,
-                    use_background_apps: args.use_background_apps ?? true,
-                    activate_app: args.activate_app ?? true,
-                };
-                const response = await fetchAPI("/experimental/operator/click", {
-                    method: "POST",
-                    body: JSON.stringify({ selector }),
-                });
-                if (!response.ok) {
-                    throw new Error(`HTTP error: ${response.status}`);
-                }
-                const data = await response.json();
-                if (!data.success) {
-                    return {
-                        content: [
-                            {
-                                type: "text",
-                                text: `Failed to click element: ${data.error || "unknown error"}`,
-                            },
-                        ],
-                    };
-                }
-                const result = data.result || {};
-                const method = result.method || "unknown";
-                const details = result.details || "click operation completed";
-                return {
-                    content: [
-                        {
-                            type: "text",
-                            text: `Successfully clicked element using ${method}. ${details}`,
-                        },
-                    ],
-                };
-            }
-            case "fill-element": {
-                const selector = {
-                    app_name: args.app,
-                    window_name: args.window,
-                    locator: `#${args.id}`,
-                    use_background_apps: args.use_background_apps ?? true,
-                    activate_app: args.activate_app ?? true,
-                };
-                const response = await fetchAPI("/experimental/operator/type", {
-                    method: "POST",
-                    body: JSON.stringify({ selector, text: args.text || "" }),
-                });
-                if (!response.ok) {
-                    throw new Error(`HTTP error: ${response.status}`);
-                }
-                const data = await response.json();
-                if (!data.success) {
-                    return {
-                        content: [
-                            {
-                                type: "text",
-                                text: `Failed to fill element: ${data.error || "unknown error"}`,
-                            },
-                        ],
-                    };
+            case "search-ui-events": {
+                const params = new URLSearchParams();
+                for (const [key, value] of Object.entries(args)) {
+                    if (value !== null && value !== undefined) {
+                        // Map event_type to the API parameter
+                        params.append(key, String(value));
+                    }
                 }
-                return {
-                    content: [
-                        { type: "text", text: "Successfully filled element with text" },
-                    ],
-                };
-            }
-            case "find-elements": {
-                const selector = {
-                    app_name: args.app,
-                    window_name: args.window,
-                    locator: args.role || "",
-                    use_background_apps: args.use_background_apps ?? true,
-                    activate_app: args.activate_app ?? true,
-                };
-                const response = await fetchAPI("/experimental/operator", {
-                    method: "POST",
-                    body: JSON.stringify({
-                        selector,
-                        max_results: args.max_results || 10,
-                        max_depth: args.max_depth,
-                    }),
-                });
+                const response = await fetchAPI(`/ui-events?${params.toString()}`);
                 if (!response.ok) {
                     throw new Error(`HTTP error: ${response.status}`);
                 }
                 const data = await response.json();
-                if (!data.success) {
-                    return {
-                        content: [
-                            {
-                                type: "text",
-                                text: `Failed to find elements: ${data.error || "unknown error"}`,
-                            },
-                        ],
-                    };
-                }
-                const elements = data.data || [];
-                if (elements.length === 0) {
+                const events = data.data || [];
+                const pagination = data.pagination || {};
+                if (events.length === 0) {
                     return {
                         content: [
                             {
                                 type: "text",
-                                text: `No elements found matching role '${args.role}' in app '${args.app}'`,
+                                text: "No UI events found. This feature requires:\n" +
+                                    "1. macOS with Accessibility permissions granted\n" +
+                                    "2. UI Events enabled in screenpipe settings\n" +
+                                    "Try: broader time range or different event_type filter.",
                             },
                         ],
                     };
                 }
-                let resultText = `Found ${elements.length} elements matching role '${args.role}' in app '${args.app}':\n\n`;
-                elements.forEach((element, i) => {
-                    resultText +=
-                        `Element ${i + 1}:\n` +
-                            `ID: ${element.id || "N/A"}\n` +
-                            `Role: ${element.role || "N/A"}\n` +
-                            `Text: ${element.text || "N/A"}\n` +
-                            `Description: ${element.description || "N/A"}\n` +
-                            "---\n";
-                });
-                return {
-                    content: [{ type: "text", text: resultText }],
-                };
-            }
-            case "scroll-element": {
-                const selector = {
-                    app_name: args.app,
-                    window_name: args.window,
-                    locator: `#${args.id}`,
-                    use_background_apps: args.use_background_apps ?? true,
-                    activate_app: args.activate_app ?? true,
-                };
-                const response = await fetchAPI("/experimental/operator/scroll", {
-                    method: "POST",
-                    body: JSON.stringify({
-                        selector,
-                        direction: args.direction,
-                        amount: args.amount,
-                    }),
-                });
-                if (!response.ok) {
-                    throw new Error(`HTTP error: ${response.status}`);
-                }
-                const data = await response.json();
-                if (!data.success) {
-                    return {
-                        content: [
-                            {
-                                type: "text",
-                                text: `Failed to scroll element: ${data.error || "unknown error"}`,
-                            },
-                        ],
-                    };
+                const formattedEvents = [];
+                for (const event of events) {
+                    const parts = [
+                        `[${event.event_type?.toUpperCase() || "?"}]`,
+                        event.app_name || "?",
+                        event.window_title ? `| ${event.window_title}` : "",
+                    ];
+                    let details = "";
+                    if (event.event_type === "text" && event.text_content) {
+                        details = `Text: "${event.text_content}"`;
+                    }
+                    else if (event.event_type === "click") {
+                        details = `Click at (${event.x || 0}, ${event.y || 0})`;
+                        if (event.element?.label) {
+                            details += ` on "${event.element.label}"`;
+                        }
+                    }
+                    else if (event.event_type === "clipboard" && event.text_content) {
+                        details = `Clipboard: "${event.text_content.substring(0, 100)}${event.text_content.length > 100 ? "..." : ""}"`;
+                    }
+                    else if (event.event_type === "app_switch" || event.event_type === "window_focus") {
+                        details = `Switched to: ${event.app_name}${event.window_title ? ` - ${event.window_title}` : ""}`;
+                    }
+                    else if (event.event_type === "scroll") {
+                        details = `Scroll: dx=${event.delta_x || 0}, dy=${event.delta_y || 0}`;
+                    }
+                    formattedEvents.push(`${parts.join(" ")}\n` +
+                        `${event.timestamp || ""}\n` +
+                        `${details}`);
                 }
+                const header = `UI Events: ${events.length}/${pagination.total || "?"}` +
+                    (pagination.total > events.length ? ` (use offset=${(pagination.offset || 0) + events.length} for more)` : "");
                 return {
                     content: [
                         {
                             type: "text",
-                            text: `Successfully scrolled element ${args.direction} by ${args.amount} pixels`,
+                            text: header + "\n\n" + formattedEvents.join("\n---\n"),
                         },
                     ],
                 };
             }
-            case "open-application": {
-                const response = await fetchAPI("/experimental/operator/open-application", {
-                    method: "POST",
-                    body: JSON.stringify({ app_name: args.app_name || "" }),
-                });
+            case "get-ui-event-stats": {
+                const params = new URLSearchParams();
+                if (args.start_time)
+                    params.append("start_time", String(args.start_time));
+                if (args.end_time)
+                    params.append("end_time", String(args.end_time));
+                const response = await fetchAPI(`/ui-events/stats?${params.toString()}`);
                 if (!response.ok) {
                     throw new Error(`HTTP error: ${response.status}`);
                 }
-                const data = await response.json();
-                if (!data.success) {
+                const stats = await response.json();
+                if (!stats || stats.length === 0) {
                     return {
                         content: [
                             {
                                 type: "text",
-                                text: `Failed to open application: ${data.error || "unknown error"}`,
+                                text: "No UI event statistics available. UI Events may not be enabled or no events have been captured yet.",
                             },
                         ],
                     };
                 }
-                return {
-                    content: [
-                        {
-                            type: "text",
-                            text: `Successfully opened application '${args.app_name}'`,
-                        },
-                    ],
-                };
-            }
-            case "open-url": {
-                const response = await fetchAPI("/experimental/operator/open-url", {
-                    method: "POST",
-                    body: JSON.stringify({
-                        url: args.url || "",
-                        browser: args.browser,
-                    }),
-                });
-                if (!response.ok) {
-                    throw new Error(`HTTP error: ${response.status}`);
-                }
-                const data = await response.json();
-                if (!data.success) {
-                    return {
-                        content: [
-                            {
-                                type: "text",
-                                text: `Failed to open URL: ${data.error || "unknown error"}`,
-                            },
-                        ],
-                    };
+                // Group by app
+                const byApp = {};
+                for (const stat of stats) {
+                    const app = stat.app_name || "Unknown";
+                    if (!byApp[app]) {
+                        byApp[app] = { app, events: {}, total: 0 };
+                    }
+                    byApp[app].events[stat.event_type] = stat.count;
+                    byApp[app].total += stat.count;
                 }
-                const browserInfo = args.browser ? ` using ${args.browser}` : "";
+                // Sort by total events
+                const sorted = Object.values(byApp).sort((a, b) => b.total - a.total);
+                const lines = sorted.map(({ app, events, total }) => {
+                    const eventDetails = Object.entries(events)
+                        .map(([type, count]) => `${type}: ${count}`)
+                        .join(", ");
+                    return `${app}: ${total} events (${eventDetails})`;
+                });
                 return {
                     content: [
                         {
                             type: "text",
-                            text: `Successfully opened URL '${args.url}'${browserInfo}`,
+                            text: `UI Event Statistics:\n\n${lines.join("\n")}`,
                         },
                     ],
                 };