windows-mcp 0.6.0__py3-none-any.whl → 0.6.1__py3-none-any.whl

windows_mcp/desktop/views.py

@@ -6,9 +6,15 @@ from PIL.Image import Image
 from enum import Enum
 
 class Browser(Enum):
-    CHROME='Chrome'
-    EDGE='Edge'
-    FIREFOX='Firefox'
+    CHROME='chrome'
+    EDGE='msedge'
+    FIREFOX='firefox'
+
+    @classmethod
+    def has_process(cls, process_name: str) -> bool:
+        if not hasattr(cls, '_process_names'):
+            cls._process_names = {f'{b.value}.exe' for b in cls}
+        return process_name.lower() in cls._process_names
 
 class Status(Enum):
     MAXIMIZED='Maximized'
@@ -18,9 +24,8 @@ class Status(Enum):
 
 
 @dataclass
-class App:
+class Window:
     name:str
-    runtime_id:tuple[int]
     is_browser:bool
     depth:int
     status:Status
@@ -41,20 +46,32 @@ class Size:
 
 @dataclass
 class DesktopState:
-    apps:list[App]
-    active_app:Optional[App]
+    active_desktop:dict
+    all_desktops:list[dict]
+    active_window:Optional[Window]
+    windows:list[Window]
     screenshot:Optional[Image]=None
     tree_state:Optional[TreeState]=None
 
-    def active_app_to_string(self):
-        if self.active_app is None:
-            return 'No active app found'
+    def active_desktop_to_string(self):
+        desktop_name=self.active_desktop.get('name')
+        headers=["Name"]
+        return tabulate([[desktop_name]], headers=headers, tablefmt="simple")
+
+    def desktops_to_string(self):
+        headers=["Name"]
+        rows=[[desktop.get("name")] for desktop in self.all_desktops]
+        return tabulate(rows, headers=headers, tablefmt="simple")
+
+    def active_window_to_string(self):
+        if not self.active_window:
+            return 'No active window found'
         headers = ["Name", "Depth", "Status", "Width", "Height", "Handle"]
-        return tabulate([self.active_app.to_row()], headers=headers, tablefmt="simple")
+        return tabulate([self.active_window.to_row()], headers=headers, tablefmt="simple")
 
-    def apps_to_string(self):
-        if not self.apps:
-            return 'No apps running in background'
+    def windows_to_string(self):
+        if not self.windows:
+            return 'No windows found'
         headers = ["Name", "Depth", "Status", "Width", "Height", "Handle"]
-        rows = [app.to_row() for app in self.apps]
+        rows = [window.to_row() for window in self.windows]
         return tabulate(rows, headers=headers, tablefmt="simple")

windows_mcp/tree/service.py

@@ -31,26 +31,26 @@ class Tree:
         self.tree_state=None
 
 
-    def get_state(self,active_app_handle:int|None,other_apps_handles:list[int],use_dom:bool=False)->TreeState:
+    def get_state(self,active_window_handle:int|None,other_windows_handles:list[int],use_dom:bool=False)->TreeState:
         # Reset DOM state to prevent leaks and stale data
         self.dom = None
         self.dom_bounding_box = None
         start_time = time()
 
-        active_app_flag=False
-        if active_app_handle:
-            active_app_flag=True
-            apps_handles=[active_app_handle]+other_apps_handles
+        active_window_flag=False
+        if active_window_handle:
+            active_window_flag=True
+            windows_handles=[active_window_handle]+other_windows_handles
         else:
-            apps_handles=other_apps_handles
+            windows_handles=other_windows_handles
         
-        interactive_nodes,scrollable_nodes,dom_informative_nodes=self.get_appwise_nodes(apps_handles=apps_handles,active_app_flag=active_app_flag,use_dom=use_dom)
+        interactive_nodes,scrollable_nodes,dom_informative_nodes=self.get_windowwise_nodes(windows_handles=windows_handles,active_window_flag=active_window_flag,use_dom=use_dom)
         root_node=TreeElementNode(
             name="Desktop",
             control_type="PaneControl",
             bounding_box=self.screen_box,
             center=self.screen_box.get_center(),
-            app_name="Desktop",
+            window_name="Desktop",
             xpath='',
             value='',
             shortcut='',
@@ -68,7 +68,7 @@ class Tree:
                 vertical_scrollable=scroll_pattern.VerticallyScrollable if scroll_pattern else False,
                 vertical_scroll_percent=scroll_pattern.VerticalScrollPercent if scroll_pattern and scroll_pattern.VerticallyScrollable else 0,
                 xpath='',
-                app_name="DOM",
+                window_name="DOM",
                 is_focused=False
             )
         else:
@@ -78,26 +78,26 @@ class Tree:
         logger.info(f"Tree State capture took {end_time - start_time:.2f} seconds")
         return self.tree_state
 
-    def get_appwise_nodes(self,apps_handles:list[int],active_app_flag:bool,use_dom:bool=False) -> tuple[list[TreeElementNode],list[ScrollElementNode],list[TextElementNode]]:
+    def get_windowwise_nodes(self,windows_handles:list[int],active_window_flag:bool,use_dom:bool=False) -> tuple[list[TreeElementNode],list[ScrollElementNode],list[TextElementNode]]:
         interactive_nodes, scrollable_nodes, dom_informative_nodes = [], [], []
         
         # Pre-calculate browser status in main thread to pass simple types to workers
         task_inputs = []
-        for handle in apps_handles:
+        for handle in windows_handles:
             is_browser = False
             try:
                 # Use temporary control for property check in main thread
                 # This is safe as we don't pass this specific COM object to the thread
                 temp_node = ControlFromHandle(handle)
-                if active_app_flag and temp_node.ClassName=='Progman':
+                if active_window_flag and temp_node.ClassName=='Progman':
                     continue
-                is_browser = self.desktop.is_app_browser(temp_node)
+                is_browser = self.desktop.is_window_browser(temp_node)
             except Exception:
                 pass
             task_inputs.append((handle, is_browser))
 
         with ThreadPoolExecutor() as executor:
-            retry_counts = {handle: 0 for handle in apps_handles}
+            retry_counts = {handle: 0 for handle in windows_handles}
             future_to_handle = {
                 executor.submit(self.get_nodes, handle, is_browser, use_dom): handle
                 for handle, is_browser in task_inputs
@@ -168,7 +168,7 @@ class Tree:
                 return False
             return first_child.LocalizedControlType==child_control_type
 
-    def _dom_correction(self, node:Control, dom_interactive_nodes:list[TreeElementNode], app_name:str):
+    def _dom_correction(self, node:Control, dom_interactive_nodes:list[TreeElementNode], window_name:str):
         if self.element_has_child_element(node,'list item','link') or self.element_has_child_element(node,'item','link'):
             dom_interactive_nodes.pop()
             return None
@@ -207,7 +207,7 @@ class Tree:
                     'bounding_box':bounding_box,
                     'xpath':'',
                     'center':center,
-                    'app_name':app_name,
+                    'window_name':window_name,
                     'is_focused':is_focused
                 }))
         elif self.element_has_child_element(node,'link','heading'):
@@ -228,11 +228,11 @@ class Tree:
                 'bounding_box':bounding_box,
                 'xpath':'',
                 'center':center,
-                'app_name':app_name,
+                'window_name':window_name,
                 'is_focused':is_focused
             }))
 
-    def tree_traversal(self, node: Control, window_bounding_box:Rect, app_name:str, is_browser:bool, 
+    def tree_traversal(self, node: Control, window_bounding_box:Rect, window_name:str, is_browser:bool, 
                     interactive_nodes:Optional[list[TreeElementNode]]=None, scrollable_nodes:Optional[list[ScrollElementNode]]=None, 
                     dom_interactive_nodes:Optional[list[TreeElementNode]]=None, dom_informative_nodes:Optional[list[TextElementNode]]=None,
                     is_dom:bool=False, is_dialog:bool=False,
@@ -277,7 +277,7 @@ class Tree:
                                 'horizontal_scroll_percent':scroll_pattern.HorizontalScrollPercent if scroll_pattern.HorizontallyScrollable else 0,
                                 'vertical_scrollable':scroll_pattern.VerticallyScrollable,
                                 'vertical_scroll_percent':scroll_pattern.VerticalScrollPercent if scroll_pattern.VerticallyScrollable else 0,
-                                'app_name':app_name,
+                                'window_name':window_name,
                                 'is_focused':has_keyboard_focus
                             }))
                     except Exception:
@@ -365,11 +365,11 @@ class Tree:
                                     'bounding_box':bounding_box,
                                     'center':center,
                                     'xpath':'',
-                                    'app_name':app_name,
+                                    'window_name':window_name,
                                     'is_focused':is_focused
                                 })
                                 dom_interactive_nodes.append(tree_node)
-                                self._dom_correction(node, dom_interactive_nodes, app_name)
+                                self._dom_correction(node, dom_interactive_nodes, window_name)
                             else:
                                 bounding_box=self.iou_bounding_box(window_bounding_box,element_bounding_box)
                                 center = bounding_box.get_center()
@@ -381,7 +381,7 @@ class Tree:
                                     'bounding_box':bounding_box,
                                     'center':center,
                                     'xpath':'',
-                                    'app_name':app_name,
+                                    'window_name':window_name,
                                     'is_focused':is_focused
                                 })
                                 interactive_nodes.append(tree_node)
@@ -432,7 +432,7 @@ class Tree:
                     height=bounding_box.height())
                     self.dom=child
                     # enter DOM subtree
-                    self.tree_traversal(child, window_bounding_box, app_name, is_browser, interactive_nodes, scrollable_nodes, dom_interactive_nodes, dom_informative_nodes, is_dom=True, is_dialog=is_dialog, element_cache_req=element_cache_req, children_cache_req=children_cache_req)
+                    self.tree_traversal(child, window_bounding_box, window_name, is_browser, interactive_nodes, scrollable_nodes, dom_interactive_nodes, dom_informative_nodes, is_dom=True, is_dialog=is_dialog, element_cache_req=element_cache_req, children_cache_req=children_cache_req)
                 # Check if the child is a dialog
                 elif isinstance(child,WindowControl):
                     if not child.CachedIsOffscreen:
@@ -454,10 +454,10 @@ class Tree:
                                 # Because this window element is modal
                                 interactive_nodes.clear()
                     # enter dialog subtree
-                    self.tree_traversal(child, window_bounding_box, app_name, is_browser, interactive_nodes, scrollable_nodes, dom_interactive_nodes, dom_informative_nodes, is_dom=is_dom, is_dialog=True, element_cache_req=element_cache_req, children_cache_req=children_cache_req)
+                    self.tree_traversal(child, window_bounding_box, window_name, is_browser, interactive_nodes, scrollable_nodes, dom_interactive_nodes, dom_informative_nodes, is_dom=is_dom, is_dialog=True, element_cache_req=element_cache_req, children_cache_req=children_cache_req)
                 else:
                     # normal non-dialog children
-                    self.tree_traversal(child, window_bounding_box, app_name, is_browser, interactive_nodes, scrollable_nodes, dom_interactive_nodes, dom_informative_nodes, is_dom=is_dom, is_dialog=is_dialog, element_cache_req=element_cache_req, children_cache_req=children_cache_req)
+                    self.tree_traversal(child, window_bounding_box, window_name, is_browser, interactive_nodes, scrollable_nodes, dom_interactive_nodes, dom_informative_nodes, is_dom=is_dom, is_dialog=is_dialog, element_cache_req=element_cache_req, children_cache_req=children_cache_req)
         except Exception as e:
             logger.error(f"Error in tree_traversal: {e}", exc_info=True)
             raise
@@ -491,11 +491,11 @@ class Tree:
             window_bounding_box=node.BoundingRectangle
             
             interactive_nodes, dom_interactive_nodes, dom_informative_nodes, scrollable_nodes = [], [], [], []
-            app_name=node.Name.strip()
-            app_name=self.app_name_correction(app_name)
+            window_name=node.Name.strip()
+            window_name=self.app_name_correction(window_name)
 
-            self.tree_traversal(node, window_bounding_box, app_name, is_browser, interactive_nodes, scrollable_nodes, dom_interactive_nodes, dom_informative_nodes, is_dom=False, is_dialog=False, element_cache_req=element_cache_req, children_cache_req=children_cache_req)
-            logger.debug(f'App name:{app_name}')
+            self.tree_traversal(node, window_bounding_box, window_name, is_browser, interactive_nodes, scrollable_nodes, dom_interactive_nodes, dom_informative_nodes, is_dom=False, is_dialog=False, element_cache_req=element_cache_req, children_cache_req=children_cache_req)
+            logger.debug(f'Window name:{window_name}')
             logger.debug(f'Interactive nodes:{len(interactive_nodes)}')
             if is_browser:
                 logger.debug(f'DOM interactive nodes:{len(dom_interactive_nodes)}')

windows_mcp/tree/utils.py

@@ -1,22 +1,22 @@
-import random
-from windows_mcp.uia import Control
-
-def random_point_within_bounding_box(node: Control, scale_factor: float = 1.0) -> tuple[int, int]:
-    """
-    Generate a random point within a scaled-down bounding box.
-
-    Args:
-        node (Control): The node with a bounding rectangle
-        scale_factor (float, optional): The factor to scale down the bounding box. Defaults to 1.0.
-
-    Returns:
-        tuple: A random point (x, y) within the scaled-down bounding box
-    """
-    box = node.BoundingRectangle
-    scaled_width = int(box.width() * scale_factor)
-    scaled_height = int(box.height() * scale_factor)
-    scaled_left = box.left + (box.width() - scaled_width) // 2
-    scaled_top = box.top + (box.height() - scaled_height) // 2
-    x = random.randint(scaled_left, scaled_left + scaled_width)
-    y = random.randint(scaled_top, scaled_top + scaled_height)
+import random
+from windows_mcp.uia import Control
+
+def random_point_within_bounding_box(node: Control, scale_factor: float = 1.0) -> tuple[int, int]:
+    """
+    Generate a random point within a scaled-down bounding box.
+
+    Args:
+        node (Control): The node with a bounding rectangle
+        scale_factor (float, optional): The factor to scale down the bounding box. Defaults to 1.0.
+
+    Returns:
+        tuple: A random point (x, y) within the scaled-down bounding box
+    """
+    box = node.BoundingRectangle
+    scaled_width = int(box.width() * scale_factor)
+    scaled_height = int(box.height() * scale_factor)
+    scaled_left = box.left + (box.width() - scaled_width) // 2
+    scaled_top = box.top + (box.height() - scaled_height) // 2
+    x = random.randint(scaled_left, scaled_left + scaled_width)
+    y = random.randint(scaled_top, scaled_top + scaled_height)
     return (x, y)

windows_mcp/tree/views.py

@@ -15,10 +15,10 @@ class TreeState:
             return "No interactive elements"
         # TOON-like format: Pipe-separated values with clear header
         # Using abbreviations in header to save tokens
-        header = "# id|app|type|name|coords|focus"
+        header = "# id|window|control_type|name|coords|focus"
         rows = [header]
         for idx, node in enumerate(self.interactive_nodes):
-            row = f"{idx}|{node.app_name}|{node.control_type}|{node.name}|{node.center.to_string()}|{node.is_focused}"
+            row = f"{idx}|{node.window_name}|{node.control_type}|{node.name}|{node.center.to_string()}|{node.is_focused}"
             rows.append(row)
         return "\n".join(rows)
 
@@ -26,11 +26,11 @@ class TreeState:
         if not self.scrollable_nodes:
             return "No scrollable elements"
         # TOON-like format
-        header = "# id|app|type|name|coords|h_scroll|h_pct|v_scroll|v_pct|focus"
+        header = "# id|window|control_type|name|coords|h_scroll|h_pct|v_scroll|v_pct|focus"
         rows = [header]
         base_index = len(self.interactive_nodes)
         for idx, node in enumerate(self.scrollable_nodes):
-            row = (f"{base_index + idx}|{node.app_name}|{node.control_type}|{node.name}|"
+            row = (f"{base_index + idx}|{node.window_name}|{node.control_type}|{node.name}|"
                    f"{node.center.to_string()}|{node.horizontal_scrollable}|{node.horizontal_scroll_percent}|"
                    f"{node.vertical_scrollable}|{node.vertical_scroll_percent}|{node.is_focused}")
             rows.append(row)
@@ -85,7 +85,7 @@ class TreeElementNode:
     center: Center
     name: str=''
     control_type: str=''
-    app_name: str=''
+    window_name: str=''
     value:str=''
     shortcut: str=''
     xpath:str=''
@@ -94,7 +94,7 @@ class TreeElementNode:
     def update_from_node(self,node:'TreeElementNode'):
         self.name=node.name
         self.control_type=node.control_type
-        self.app_name=node.app_name
+        self.window_name=node.window_name
         self.value=node.value
         self.shortcut=node.shortcut
         self.bounding_box=node.bounding_box
@@ -104,14 +104,14 @@ class TreeElementNode:
 
     # Legacy method kept for compatibility if needed, but not used in new format
     def to_row(self, index: int):
-        return [index, self.app_name, self.control_type, self.name, self.value, self.shortcut, self.center.to_string(),self.is_focused]
+        return [index, self.window_name, self.control_type, self.name, self.value, self.shortcut, self.center.to_string(),self.is_focused]
 
 @dataclass
 class ScrollElementNode:
     name: str
     control_type: str
     xpath:str
-    app_name: str
+    window_name: str
     bounding_box: BoundingBox
     center: Center
     horizontal_scrollable: bool
@@ -124,7 +124,7 @@ class ScrollElementNode:
     def to_row(self, index: int, base_index: int):
         return [
             base_index + index,
-            self.app_name,
+            self.window_name,
             self.control_type,
             self.name,
             self.center.to_string(),

windows_mcp/uia/controls.py

@@ -1458,48 +1458,6 @@ class Control():
         self.SetFocus()
         SendKeys(text, interval, waitTime, charMode)
 
-    def GetPixelColor(self, x: int, y: int) -> Optional[int]:
-        """
-        Call native `GetPixelColor` if control has a valid native handle.
-        Use `self.ToBitmap` if control doesn't have a valid native handle or you get many pixels.
-        x: int, internal x position.
-        y: int, internal y position.
-        Return int, a color value in bgr.
-        r = bgr & 0x0000FF
-        g = (bgr & 0x00FF00) >> 8
-        b = (bgr & 0xFF0000) >> 16
-        """
-        handle = self.NativeWindowHandle
-        if handle:
-            return GetPixelColor(x, y, handle)
-        return None
-
-    def ToBitmap(self, x: int = 0, y: int = 0, width: int = 0, height: int = 0,
-                 captureCursor: bool = False) -> Optional[Bitmap]:
-        """
-        Capture control to a `Bitmap` object.
-        x, y: int, the point in control's internal position(from 0,0).
-        width, height: int, image's width and height from x, y, use 0 for entire area.
-                       If width(or height) < 0, image size will be control's width(or height) - width(or height).
-        """
-        return Bitmap.FromControl(self, x, y, width, height, captureCursor)
-
-    def CaptureToImage(self, savePath: str, x: int = 0, y: int = 0, width: int = 0, height: int = 0,
-                       captureCursor: bool = False) -> bool:
-        """
-        Capture control to a image file.
-        savePath: str, should end with .bmp, .jpg, .jpeg, .png, .gif, .tif, .tiff.
-        x, y: int, the point in control's internal position(from 0,0).
-        width, height: int, image's width and height from x, y, use 0 for entire area.
-                       If width(or height) < 0, image size will be control's width(or height) - width(or height).
-        Return bool, True if succeed otherwise False.
-        """
-        bitmap = Bitmap.FromControl(self, x, y, width, height, captureCursor)
-        if bitmap:
-            with bitmap:
-                return bitmap.ToFile(savePath)
-        return False
-
     def IsTopLevel(self) -> bool:
         """Determine whether current control is top level."""
         handle = self.NativeWindowHandle