screenpipe-mcp 0.5.0 → 0.7.0

package/src/index.ts

@@ -30,12 +30,6 @@ function getCurrentDateInfo(): { isoDate: string; localDate: string } {
   };
 }
 
-// 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;
@@ -51,7 +45,7 @@ const SCREENPIPE_API = `http://localhost:${port}`;
 const server = new Server(
   {
     name: "screenpipe",
-    version: "0.5.0",
+    version: "0.7.0",
   },
   {
     capabilities: {
@@ -85,7 +79,7 @@ const BASE_TOOLS: Tool[] = [
         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: {
@@ -129,57 +123,15 @@ const BASE_TOOLS: Tool[] = [
           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"],
     },
   },
   {
@@ -220,236 +172,91 @@ const BASE_TOOLS: Tool[] = [
       required: ["start_time", "end_time"],
     },
   },
-];
-
-const MACOS_TOOLS: Tool[] = [
   {
-    name: "find-elements",
+    name: "search-ui-events",
     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.",
+      "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",
-        },
-        use_background_apps: {
-          type: "boolean",
-          description: "Whether to look in background apps",
-          default: true,
+          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.",
         },
-        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",
+          description: "Max results. Default: 50",
+          default: 50,
         },
-        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,
-        },
-      },
-      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(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
@@ -518,18 +325,20 @@ server.setRequestHandler(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) |
@@ -540,11 +349,27 @@ server.setRequestHandler(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)`,
           },
         ],
       };
@@ -750,27 +575,6 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
     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": {
@@ -860,50 +664,6 @@ server.setRequestHandler(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 as { x: number; y: number };
-          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 as string;
         const endTime = args.end_time as string;
@@ -976,7 +736,8 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
         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<{
           success: boolean;
@@ -995,6 +756,11 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
             }
           }, 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;
@@ -1070,259 +836,131 @@ server.setRequestHandler(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 events = data.data || [];
+        const pagination = data.pagination || {};
 
-        const elements = data.data || [];
-        if (elements.length === 0) {
+        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: any, i: number) => {
-          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,
-          }),
-        });
+        const formattedEvents: string[] = [];
+        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}`;
+          }
 
-        if (!response.ok) {
-          throw new Error(`HTTP error: ${response.status}`);
+          formattedEvents.push(
+            `${parts.join(" ")}\n` +
+            `${event.timestamp || ""}\n` +
+            `${details}`
+          );
         }
 
-        const data = await response.json();
-        if (!data.success) {
-          return {
-            content: [
-              {
-                type: "text",
-                text: `Failed to scroll element: ${data.error || "unknown error"}`,
-              },
-            ],
-          };
-        }
+        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}`);
+        // Group by app
+        const byApp: Record<string, { app: string; events: Record<string, number>; total: number }> = {};
+        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 data = await response.json();
-        if (!data.success) {
-          return {
-            content: [
-              {
-                type: "text",
-                text: `Failed to open URL: ${data.error || "unknown error"}`,
-              },
-            ],
-          };
-        }
+        // 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})`;
+        });
 
-        const browserInfo = args.browser ? ` using ${args.browser}` : "";
         return {
           content: [
             {
               type: "text",
-              text: `Successfully opened URL '${args.url}'${browserInfo}`,
+              text: `UI Event Statistics:\n\n${lines.join("\n")}`,
             },
           ],
         };