agentcrew-ai 0.8.11__tar.gz → 0.8.13__tar.gz

agentcrew_ai-0.8.13/AgentCrew/__init__.py

@@ -0,0 +1 @@
+__version__ = "0.8.13"

{agentcrew_ai-0.8.11 → agentcrew_ai-0.8.13}/AgentCrew/app.py

@@ -265,7 +265,8 @@ class AgentCrewApplication:
             search_service = None
 
         try:
-            code_analysis_service = CodeAnalysisService()
+            code_analysis_llm = llm_manager.initialize_standalone_service(provider)
+            code_analysis_service = CodeAnalysisService(llm_service=code_analysis_llm)
         except Exception as e:
             click.echo(f"⚠️ Code analysis tool not available: {str(e)}")
             code_analysis_service = None

{agentcrew_ai-0.8.11 → agentcrew_ai-0.8.13}/AgentCrew/main.py

@@ -7,6 +7,20 @@ import platform
 from AgentCrew.app import common_options
 
 
+def _custom_unraisable_hook(unraisable):
+    """Suppress httpcore async cleanup exceptions when streams are cancelled."""
+    exc_type = unraisable.exc_type
+    exc_value = unraisable.exc_value
+    if exc_type and exc_type.__name__ == "AsyncLibraryNotFoundError":
+        return
+    if exc_value and "httpcore" in str(type(exc_value).__module__):
+        return
+    sys.__unraisablehook__(unraisable)
+
+
+sys.unraisablehook = _custom_unraisable_hook
+
+
 PROVIDER_LIST = [
     "claude",
     "groq",
@@ -72,7 +86,7 @@ def check_and_update():
         current_version = get_current_version()
 
         click.echo(f"Current version: {current_version}\nChecking for updates...")
-        latest_version = get_latest_github_version()
+        latest_version, release_notes = get_latest_release_info()
 
         if not current_version or not latest_version:
             click.echo("⚠️ Could not determine version information", err=True)
@@ -84,8 +98,20 @@ def check_and_update():
             system = platform.system().lower()
 
             if system == "linux" or system == "darwin":
+                click.echo("\n" + "=" * 60)
+                click.echo("🔄 New version available!")
+                click.echo("=" * 60)
+
+                if release_notes:
+                    click.echo("\n📝 Release Notes:")
+                    click.echo("-" * 40)
+                    click.echo(release_notes)
+                    click.echo("-" * 40 + "\n")
+                else:
+                    click.echo("\n⚠️ Could not fetch release notes.")
+
                 if click.confirm(
-                    "🔄 New version available! Do you want to update now?",
+                    "\nDo you want to update now?",
                     default=False,
                 ):
                     click.echo("🔄 Starting update...")
@@ -95,7 +121,18 @@ def check_and_update():
                     click.echo("⏭️ Skipping update. Starting application...")
             else:
                 command = "uv tool install --python=3.12 --reinstall agentcrew-ai[cpu]@latest --index https://download.pytorch.org/whl/cpu --index-strategy unsafe-best-match"
-                click.echo(f"🔄 New version available!\nRun {command} to update.")
+
+                click.echo("\n" + "=" * 60)
+                click.echo("🔄 New version available!")
+                click.echo("=" * 60)
+
+                if release_notes:
+                    click.echo("\n📝 Release Notes:")
+                    click.echo("-" * 40)
+                    click.echo(release_notes)
+                    click.echo("-" * 40 + "\n")
+
+                click.echo(f"Run the following command to update:\n\n{command}")
         else:
             click.echo("✅ You are running the latest version")
 
@@ -143,6 +180,35 @@ def get_latest_github_version():
         return None
 
 
+def get_latest_release_info():
+    """Get the latest release information including version and release notes from GitHub
+
+    Returns:
+        tuple: (version, release_notes) where both can be None if not found.
+    """
+    try:
+        api_url = (
+            "https://api.github.com/repos/saigontechnology/AgentCrew/releases/latest"
+        )
+        response = requests.get(api_url, timeout=10)
+
+        if response.status_code == 200:
+            release_data = response.json()
+            tag_name = release_data.get("tag_name", "").lstrip("v")
+            name = release_data.get("name", "")
+            body = release_data.get("body", "")
+
+            release_notes = None
+            if body:
+                release_notes = f"## {name or tag_name}\n\n{body}"
+
+            return tag_name, release_notes
+
+        return None, None
+    except Exception:
+        return None, None
+
+
 def version_is_older(current: str, latest: str) -> bool:
     """
     Compare two semantic version strings to check if current is older than latest.

{agentcrew_ai-0.8.11 → agentcrew_ai-0.8.13}/AgentCrew/main_docker.py

@@ -3,6 +3,20 @@ import os
 import sys
 
 
+def _custom_unraisable_hook(unraisable):
+    """Suppress httpcore async cleanup exceptions when streams are cancelled."""
+    exc_type = unraisable.exc_type
+    exc_value = unraisable.exc_value
+    if exc_type and exc_type.__name__ == "AsyncLibraryNotFoundError":
+        return
+    if exc_value and "httpcore" in str(type(exc_value).__module__):
+        return
+    sys.__unraisablehook__(unraisable)
+
+
+sys.unraisablehook = _custom_unraisable_hook
+
+
 PROVIDER_LIST = [
     "claude",
     "groq",

{agentcrew_ai-0.8.11 → agentcrew_ai-0.8.13}/AgentCrew/modules/agents/local_agent.py

@@ -586,16 +586,16 @@ You must analyze then execute it with your available tools and give answer witho
             )
         adaptive_text.extend(
             [
-                "<Global_Behavior id='default'>When encountering tasks that you have no data in the context and you don't know the anwser, say I don't know and ask user for helping you find the solution.</Global_Behavior>",
                 "<Global_Behavior id='transfer'>When working on my request, consider whether if any other agents is more suitable, if yes, transfer to that agent.</Global_Behavior>",
+                "<Global_Behavior id='default'>When encountering tasks that you have no data in the context and you don't know the anwser, say I don't know and ask user for helping you find the solution.</Global_Behavior>",
             ]
         )
         if len(adaptive_text) > 0:
             adaptive_messages["content"].append(
                 {
                     "type": "text",
-                    "text": f"""Go through all behaviors in the <Adaptive_Behaviors> tags before generating responses. 
-Whenever condition `when` in <Global_Behavior> or <Project_Behavior> matches, tailor your responses with behaviors immediately—they override default instruction.
+                    "text": f"""Read through all behaviors in the <Adaptive_Behaviors> tags before generating responses. 
+Whenever condition on `when` clause in a **Behavior** matches, tailor your responses with that **Behavior** immediately, override default instruction.
 <Project_Behavior> has higher priority than <Global_Behavior>.
 <Adaptive_Behaviors>
 {"  \n".join(adaptive_text)}
@@ -604,6 +604,21 @@ Whenever condition `when` in <Global_Behavior> or <Project_Behavior> matches, ta
             )
         return adaptive_messages
 
+    def _get_directory_structure(self) -> str:
+        try:
+            cwd = os.getcwd()
+            entries = []
+            for entry in sorted(os.listdir(cwd)):
+                full_path = os.path.join(cwd, entry)
+                if os.path.isdir(full_path):
+                    entries.append(f"{entry}/")
+                else:
+                    entries.append(entry)
+            return "\n".join(entries) if entries else ""
+        except Exception as e:
+            logger.warning(f"Failed to get directory structure: {e}")
+            return ""
+
     def _enhance_agent_context_messages(self, final_messages: List[Dict[str, Any]]):
         last_user_index = next(
             (
@@ -624,22 +639,6 @@ Whenever condition `when` in <Global_Behavior> or <Project_Behavior> matches, ta
             .find("<Transfer_Tool>")
             != 0
         ):
-            #         if (
-            #             self.services.get("agent_manager")
-            #             and self.services["agent_manager"].enforce_transfer
-            #         ):
-            #             adaptive_messages["content"].insert(
-            #                 0,
-            #                 {
-            #                     "type": "text",
-            #                     "text": """Before processing my request:
-            # - Break my request into sub-tasks when applicable.
-            # - For each sub-task, evaluate other agents capabilities.
-            # - Transfer sub-task to other agent if they are more suitable.
-            # - Keep the evaluating quick and concise using xml format within <agent_evaluation> tags.
-            # - Skip agent evaluation if user request is when...,[action]... related to adaptive behaviors call `adapt` tool instead.""",
-            #                 },
-            #             )
             if not self.is_remoting_mode and self.services.get("memory"):
                 memory_headers = self.services["memory"].list_memory_headers(
                     agent_name=self.name
@@ -648,9 +647,35 @@ Whenever condition `when` in <Global_Behavior> or <Project_Behavior> matches, ta
                     adaptive_messages["content"].append(
                         {
                             "type": "text",
-                            "text": f"Check the conversation histories if it related to my request:\n - {'\n - '.join(memory_headers)}",
+                            "text": f"Belows are our last 20 discussion headlines:\n - {'\n - '.join(memory_headers)}",
                         }
                     )
+            if (
+                self.services.get("agent_manager")
+                and self.services["agent_manager"].enforce_transfer
+            ):
+                adaptive_messages["content"].insert(
+                    0,
+                    {
+                        "type": "text",
+                        "text": """Before processing my request:
+            - Break my request into actionable sub-tasks when applicable.
+            - For each sub-task, evaluate your tools and plan tool strategy for acquiring the context you need for the main task.
+            - Action subsequent steps base on your plan.
+            - Keep the evaluating quick and concise using xml format within <agent_evaluation> tags.
+            - Skip agent evaluation if user request is when...,[action]... related to adaptive behaviors call `adapt` tool instead.""",
+                    },
+                )
+        if last_user_index == 0:
+            dir_structure = self._get_directory_structure()
+            if dir_structure:
+                adaptive_messages["content"].append(
+                    {
+                        "type": "text",
+                        "text": f"Cwd structure:\n{dir_structure}",
+                    }
+                )
+
         if len(adaptive_messages["content"]) > 0:
             final_messages.insert(last_user_index, adaptive_messages)
 

{agentcrew_ai-0.8.11 → agentcrew_ai-0.8.13}/AgentCrew/modules/browser_automation/js_loader.py

@@ -254,17 +254,114 @@ class JavaScriptExecutor:
             logger.error(f"Error during typing simulation: {e}")
             return {"success": False, "error": f"Typing simulation failed: {str(e)}"}
 
+    @staticmethod
+    def _get_key_definition(key: str) -> Optional[Dict[str, Any]]:
+        """
+        Get key definition for a given key.
+        Handles both predefined special keys and dynamic alphanumeric keys.
+        """
+        key_name = key.lower().strip()
+
+        if key_name in key_definitions:
+            return key_definitions[key_name]
+
+        if len(key) == 1:
+            char = key
+            char_lower = char.lower()
+            char_upper = char.upper()
+
+            if char_lower.isalpha():
+                key_code = ord(char_upper)
+                return {
+                    "keyCode": key_code,
+                    "key": char_lower,
+                    "code": f"Key{char_upper}",
+                    "text": char_lower,
+                }
+            elif char.isdigit():
+                key_code = ord(char)
+                return {
+                    "keyCode": key_code,
+                    "key": char,
+                    "code": f"Digit{char}",
+                    "text": char,
+                }
+            else:
+                symbol_map = {
+                    "`": {"keyCode": 192, "code": "Backquote", "key": "`", "text": "`"},
+                    "-": {"keyCode": 189, "code": "Minus", "key": "-", "text": "-"},
+                    "=": {"keyCode": 187, "code": "Equal", "key": "=", "text": "="},
+                    "[": {
+                        "keyCode": 219,
+                        "code": "BracketLeft",
+                        "key": "[",
+                        "text": "[",
+                    },
+                    "]": {
+                        "keyCode": 221,
+                        "code": "BracketRight",
+                        "key": "]",
+                        "text": "]",
+                    },
+                    "\\": {
+                        "keyCode": 220,
+                        "code": "Backslash",
+                        "key": "\\",
+                        "text": "\\",
+                    },
+                    ";": {"keyCode": 186, "code": "Semicolon", "key": ";", "text": ";"},
+                    "'": {"keyCode": 222, "code": "Quote", "key": "'", "text": "'"},
+                    ",": {"keyCode": 188, "code": "Comma", "key": ",", "text": ","},
+                    ".": {"keyCode": 190, "code": "Period", "key": ".", "text": "."},
+                    "/": {"keyCode": 191, "code": "Slash", "key": "/", "text": "/"},
+                    "~": {"keyCode": 192, "code": "Backquote", "key": "~", "text": "~"},
+                    "!": {"keyCode": 49, "code": "Digit1", "key": "!", "text": "!"},
+                    "@": {"keyCode": 50, "code": "Digit2", "key": "@", "text": "@"},
+                    "#": {"keyCode": 51, "code": "Digit3", "key": "#", "text": "#"},
+                    "$": {"keyCode": 52, "code": "Digit4", "key": "$", "text": "$"},
+                    "%": {"keyCode": 53, "code": "Digit5", "key": "%", "text": "%"},
+                    "^": {"keyCode": 54, "code": "Digit6", "key": "^", "text": "^"},
+                    "&": {"keyCode": 55, "code": "Digit7", "key": "&", "text": "&"},
+                    "*": {"keyCode": 56, "code": "Digit8", "key": "*", "text": "*"},
+                    "(": {"keyCode": 57, "code": "Digit9", "key": "(", "text": "("},
+                    ")": {"keyCode": 48, "code": "Digit0", "key": ")", "text": ")"},
+                    "_": {"keyCode": 189, "code": "Minus", "key": "_", "text": "_"},
+                    "+": {"keyCode": 187, "code": "Equal", "key": "+", "text": "+"},
+                    "{": {
+                        "keyCode": 219,
+                        "code": "BracketLeft",
+                        "key": "{",
+                        "text": "{",
+                    },
+                    "}": {
+                        "keyCode": 221,
+                        "code": "BracketRight",
+                        "key": "}",
+                        "text": "}",
+                    },
+                    "|": {"keyCode": 220, "code": "Backslash", "key": "|", "text": "|"},
+                    ":": {"keyCode": 186, "code": "Semicolon", "key": ":", "text": ":"},
+                    '"': {"keyCode": 222, "code": "Quote", "key": '"', "text": '"'},
+                    "<": {"keyCode": 188, "code": "Comma", "key": "<", "text": "<"},
+                    ">": {"keyCode": 190, "code": "Period", "key": ">", "text": ">"},
+                    "?": {"keyCode": 191, "code": "Slash", "key": "?", "text": "?"},
+                }
+                if char in symbol_map:
+                    return symbol_map[char]
+
+        return None
+
     @staticmethod
     def dispatch_key_event(
         chrome_interface: Any, key: str, modifiers: Optional[list] = None
     ) -> Dict[str, Any]:
         """
-        Dispatch key events using CDP.
+        Dispatch key events using CDP with full key definition support.
 
         Args:
             chrome_interface: Chrome DevTools Protocol interface
-            key: Key to dispatch (e.g., 'Enter', 'Up', 'Down')
-            modifiers: Optional list of modifiers ('ctrl', 'alt', 'shift')
+            key: Key to dispatch (e.g., 'a', 'Enter', 'Up', 'F1', any single character)
+            modifiers: Optional list of modifiers ('ctrl', 'alt', 'shift', 'meta')
 
         Returns:
             Result dictionary with success status
@@ -273,60 +370,94 @@ class JavaScriptExecutor:
             modifiers = []
 
         try:
-            key_name = key.lower().strip()
-            key_code = key_codes.get(key_name)
+            key_def = JavaScriptExecutor._get_key_definition(key)
 
-            if key_code is None:
+            if key_def is None:
                 return {
                     "success": False,
-                    "error": f"Unknown key '{key}'. Supported keys: {', '.join(sorted(key_codes.keys()))}",
+                    "error": f"Unknown key '{key}'. Supported: a-z, 0-9, symbols, and special keys (enter, escape, tab, f1-f12, up, down, left, right, etc.)",
                     "key": key,
                     "modifiers": modifiers,
                 }
 
+            key_code = key_def["keyCode"]
+            key_value = key_def["key"]
+            code_value = key_def["code"]
+            location = key_def.get("location", 0)
+            text_value = key_def.get("text", "")
+
             modifier_flags = 0
+            modifier_keys_to_press = []
             if modifiers:
                 modifier_names = [m.strip().lower() for m in modifiers]
                 for mod in modifier_names:
                     if mod in ["alt"]:
                         modifier_flags |= 1
+                        modifier_keys_to_press.append("alt")
                     elif mod in ["ctrl", "control"]:
                         modifier_flags |= 2
+                        modifier_keys_to_press.append("ctrl")
                     elif mod in ["meta", "cmd", "command"]:
                         modifier_flags |= 4
+                        modifier_keys_to_press.append("meta")
                     elif mod in ["shift"]:
                         modifier_flags |= 8
+                        modifier_keys_to_press.append("shift")
+
+            for mod_key in modifier_keys_to_press:
+                mod_def = key_definitions.get(mod_key)
+                if mod_def:
+                    chrome_interface.Input.dispatchKeyEvent(
+                        type="keyDown",
+                        key=mod_def["key"],
+                        code=mod_def["code"],
+                        windowsVirtualKeyCode=mod_def["keyCode"],
+                        location=mod_def.get("location", 0),
+                        modifiers=modifier_flags,
+                    )
 
             chrome_interface.Input.dispatchKeyEvent(
-                type="rawKeyDown",
+                type="keyDown",
+                key=key_value,
+                code=code_value,
                 windowsVirtualKeyCode=key_code,
+                location=location,
                 modifiers=modifier_flags,
             )
 
-            printable_keys = {"space", "spacebar", "enter", "return", "tab"}
-            if key_name in printable_keys:
-                if key_name in ["space", "spacebar"]:
-                    char_text = " "
-                elif key_name in ["enter", "return"]:
-                    char_text = "\r"
-                elif key_name == "tab":
-                    char_text = "\t"
-                else:
-                    char_text = ""
-
-                if char_text:
-                    chrome_interface.Input.dispatchKeyEvent(
-                        type="char",
-                        windowsVirtualKeyCode=key_code,
-                        text=char_text,
-                        unmodifiedText=char_text,
-                        modifiers=modifier_flags,
-                    )
+            if text_value:
+                chrome_interface.Input.dispatchKeyEvent(
+                    type="char",
+                    key=key_value,
+                    code=code_value,
+                    windowsVirtualKeyCode=key_code,
+                    text=text_value,
+                    unmodifiedText=text_value,
+                    location=location,
+                    modifiers=modifier_flags,
+                )
 
             chrome_interface.Input.dispatchKeyEvent(
-                type="keyUp", windowsVirtualKeyCode=key_code, modifiers=modifier_flags
+                type="keyUp",
+                key=key_value,
+                code=code_value,
+                windowsVirtualKeyCode=key_code,
+                location=location,
+                modifiers=modifier_flags,
             )
 
+            for mod_key in reversed(modifier_keys_to_press):
+                mod_def = key_definitions.get(mod_key)
+                if mod_def:
+                    chrome_interface.Input.dispatchKeyEvent(
+                        type="keyUp",
+                        key=mod_def["key"],
+                        code=mod_def["code"],
+                        windowsVirtualKeyCode=mod_def["keyCode"],
+                        location=mod_def.get("location", 0),
+                        modifiers=0,
+                    )
+
             time.sleep(0.1)
 
             return {
@@ -334,6 +465,8 @@ class JavaScriptExecutor:
                 "message": f"Successfully dispatched key '{key}' with modifiers '{modifiers}'",
                 "key": key,
                 "key_code": key_code,
+                "key_value": key_value,
+                "code_value": code_value,
                 "modifiers": modifiers,
                 "modifier_flags": modifier_flags,
             }
@@ -501,58 +634,69 @@ class JavaScriptLoader:
 
 js_loader = JavaScriptLoader()
 
-key_codes = {
-    "up": 38,
-    "down": 40,
-    "left": 37,
-    "right": 39,
-    "home": 36,
-    "end": 35,
-    "pageup": 33,
-    "pagedown": 34,
-    "enter": 13,
-    "escape": 27,
-    "tab": 9,
-    "backspace": 8,
-    "delete": 46,
-    "space": 32,
-    "f1": 112,
-    "f2": 113,
-    "f3": 114,
-    "f4": 115,
-    "f5": 116,
-    "f6": 117,
-    "f7": 118,
-    "f8": 119,
-    "f9": 120,
-    "f10": 121,
-    "f11": 122,
-    "f12": 123,
-    "numpad0": 96,
-    "numpad1": 97,
-    "numpad2": 98,
-    "numpad3": 99,
-    "numpad4": 100,
-    "numpad5": 101,
-    "numpad6": 102,
-    "numpad7": 103,
-    "numpad8": 104,
-    "numpad9": 105,
-    "volumeup": 175,
-    "volume_up": 175,
-    "volumedown": 174,
-    "volume_down": 174,
-    "volumemute": 173,
-    "volume_mute": 173,
-    "capslock": 20,
-    "numlock": 144,
-    "scrolllock": 145,
-    "shift": 16,
-    "ctrl": 17,
-    "control": 17,
-    "alt": 18,
-    "meta": 91,
-    "cmd": 91,
-    "command": 91,
-    "windows": 91,
+key_definitions = {
+    "up": {"keyCode": 38, "key": "ArrowUp", "code": "ArrowUp"},
+    "down": {"keyCode": 40, "key": "ArrowDown", "code": "ArrowDown"},
+    "left": {"keyCode": 37, "key": "ArrowLeft", "code": "ArrowLeft"},
+    "right": {"keyCode": 39, "key": "ArrowRight", "code": "ArrowRight"},
+    "home": {"keyCode": 36, "key": "Home", "code": "Home"},
+    "end": {"keyCode": 35, "key": "End", "code": "End"},
+    "pageup": {"keyCode": 33, "key": "PageUp", "code": "PageUp"},
+    "pagedown": {"keyCode": 34, "key": "PageDown", "code": "PageDown"},
+    "enter": {"keyCode": 13, "key": "Enter", "code": "Enter", "text": "\r"},
+    "escape": {"keyCode": 27, "key": "Escape", "code": "Escape"},
+    "tab": {"keyCode": 9, "key": "Tab", "code": "Tab", "text": "\t"},
+    "backspace": {"keyCode": 8, "key": "Backspace", "code": "Backspace"},
+    "delete": {"keyCode": 46, "key": "Delete", "code": "Delete"},
+    "space": {"keyCode": 32, "key": " ", "code": "Space", "text": " "},
+    "insert": {"keyCode": 45, "key": "Insert", "code": "Insert"},
+    "f1": {"keyCode": 112, "key": "F1", "code": "F1"},
+    "f2": {"keyCode": 113, "key": "F2", "code": "F2"},
+    "f3": {"keyCode": 114, "key": "F3", "code": "F3"},
+    "f4": {"keyCode": 115, "key": "F4", "code": "F4"},
+    "f5": {"keyCode": 116, "key": "F5", "code": "F5"},
+    "f6": {"keyCode": 117, "key": "F6", "code": "F6"},
+    "f7": {"keyCode": 118, "key": "F7", "code": "F7"},
+    "f8": {"keyCode": 119, "key": "F8", "code": "F8"},
+    "f9": {"keyCode": 120, "key": "F9", "code": "F9"},
+    "f10": {"keyCode": 121, "key": "F10", "code": "F10"},
+    "f11": {"keyCode": 122, "key": "F11", "code": "F11"},
+    "f12": {"keyCode": 123, "key": "F12", "code": "F12"},
+    "numpad0": {"keyCode": 96, "key": "0", "code": "Numpad0", "location": 3},
+    "numpad1": {"keyCode": 97, "key": "1", "code": "Numpad1", "location": 3},
+    "numpad2": {"keyCode": 98, "key": "2", "code": "Numpad2", "location": 3},
+    "numpad3": {"keyCode": 99, "key": "3", "code": "Numpad3", "location": 3},
+    "numpad4": {"keyCode": 100, "key": "4", "code": "Numpad4", "location": 3},
+    "numpad5": {"keyCode": 101, "key": "5", "code": "Numpad5", "location": 3},
+    "numpad6": {"keyCode": 102, "key": "6", "code": "Numpad6", "location": 3},
+    "numpad7": {"keyCode": 103, "key": "7", "code": "Numpad7", "location": 3},
+    "numpad8": {"keyCode": 104, "key": "8", "code": "Numpad8", "location": 3},
+    "numpad9": {"keyCode": 105, "key": "9", "code": "Numpad9", "location": 3},
+    "volumeup": {"keyCode": 175, "key": "AudioVolumeUp", "code": "AudioVolumeUp"},
+    "volume_up": {"keyCode": 175, "key": "AudioVolumeUp", "code": "AudioVolumeUp"},
+    "volumedown": {"keyCode": 174, "key": "AudioVolumeDown", "code": "AudioVolumeDown"},
+    "volume_down": {
+        "keyCode": 174,
+        "key": "AudioVolumeDown",
+        "code": "AudioVolumeDown",
+    },
+    "volumemute": {"keyCode": 173, "key": "AudioVolumeMute", "code": "AudioVolumeMute"},
+    "volume_mute": {
+        "keyCode": 173,
+        "key": "AudioVolumeMute",
+        "code": "AudioVolumeMute",
+    },
+    "capslock": {"keyCode": 20, "key": "CapsLock", "code": "CapsLock"},
+    "numlock": {"keyCode": 144, "key": "NumLock", "code": "NumLock"},
+    "scrolllock": {"keyCode": 145, "key": "ScrollLock", "code": "ScrollLock"},
+    "shift": {"keyCode": 16, "key": "Shift", "code": "ShiftLeft", "location": 1},
+    "ctrl": {"keyCode": 17, "key": "Control", "code": "ControlLeft", "location": 1},
+    "control": {"keyCode": 17, "key": "Control", "code": "ControlLeft", "location": 1},
+    "alt": {"keyCode": 18, "key": "Alt", "code": "AltLeft", "location": 1},
+    "meta": {"keyCode": 91, "key": "Meta", "code": "MetaLeft", "location": 1},
+    "cmd": {"keyCode": 91, "key": "Meta", "code": "MetaLeft", "location": 1},
+    "command": {"keyCode": 91, "key": "Meta", "code": "MetaLeft", "location": 1},
+    "windows": {"keyCode": 91, "key": "Meta", "code": "MetaLeft", "location": 1},
 }
+
+key_codes = {k: v["keyCode"] for k, v in key_definitions.items()}