updates to app_framework

Author: rgarcia

src/kernel/__init__.py

@@ -28,13 +28,13 @@
 from ._utils._logs import setup_logging as _setup_logging
 from .app_framework import (
     App,
-    Browser,
-    Browsers,
     KernelApp,
+    KernelJson,
     KernelAction,
+    KernelAppJson,
     KernelContext,
+    KernelActionJson,
     KernelAppRegistry,
-    browsers,
     app_registry,
     export_registry,
 )
@@ -79,12 +79,12 @@
     "DefaultHttpxClient",
     "DefaultAsyncHttpxClient",
     "KernelContext",
-    "Browser",
     "KernelAction",
+    "KernelActionJson",
+    "KernelAppJson",
+    "KernelJson",
     "KernelApp",
     "KernelAppRegistry",
-    "Browsers",
-    "browsers",
     "App",
     "app_registry",
     "export_registry",

src/kernel/app_framework.py

@@ -6,27 +6,36 @@
 
 T = TypeVar("T")
 
-
 # Context definition
 @dataclass
 class KernelContext:
     """Context object passed to action handlers"""
-
     invocation_id: str
 
-
-# Browser definition
-class Browser:
-    def __init__(self, cdp_ws_url: str):
-        self.cdp_ws_url = cdp_ws_url
-
-
 # Action definition
+@dataclass
 class KernelAction:
-    def __init__(self, name: str, handler: Callable[..., Any]):
-        self.name = name
-        self.handler = handler
+    """Action that can be invoked on a Kernel app"""
+    name: str
+    handler: Callable[..., Any]
 
+# JSON interfaces
+@dataclass
+class KernelActionJson:
+    """JSON representation of a Kernel action"""
+    name: str
+
+@dataclass
+class KernelAppJson:
+    """JSON representation of a Kernel app"""
+    name: str
+    actions: List[KernelActionJson]
+
+@dataclass
+class KernelJson:
+    """JSON representation of Kernel manifest"""
+    apps: List[KernelAppJson]
+    entrypoint: str
 
 # App class
 class KernelApp:
@@ -36,22 +45,20 @@ def __init__(self, name: str):
         # Register this app in the global registry
         _app_registry.register_app(self)
 
-    def action(self, name_or_handler: Optional[Union[str, Callable[..., Any]]] = None):
+    def action(self, name_or_handler: Optional[Union[str, Callable[..., Any]]] = None) -> Callable[..., Any]:
         """Decorator to register an action with the app"""
         if name_or_handler is None:
             # This is the @app.action() case, which should return the decorator
-            def decorator(f: Callable[..., Any]):
+            def decorator(f: Callable[..., Any]) -> Callable[..., Any]:
                 return self._register_action(f.__name__, f)
-
             return decorator
         elif callable(name_or_handler):
             # This is the @app.action case (handler passed directly)
             return self._register_action(name_or_handler.__name__, name_or_handler)
         else:
             # This is the @app.action("name") case (name_or_handler is a string)
-            def decorator(f: Callable[..., Any]):
+            def decorator(f: Callable[..., Any]) -> Callable[..., Any]:
                 return self._register_action(name_or_handler, f)  # name_or_handler is the name string here
-
             return decorator
 
     def _register_action(self, name: str, handler: Callable[..., Any]) -> Callable[..., Any]:
@@ -98,14 +105,17 @@ def get_action(self, name: str) -> Optional[KernelAction]:
         """Get an action by name"""
         return self.actions.get(name)
 
-    def to_dict(self) -> Dict[str, Any]:
+    def to_dict(self) -> KernelAppJson:
         """Export app information without handlers"""
-        return {"name": self.name, "actions": [{"name": action.name} for action in self.get_actions()]}
+        return KernelAppJson(
+            name=self.name,
+            actions=[KernelActionJson(name=action.name) for action in self.get_actions()]
+        )
 
 
 # Registry for storing Kernel apps
 class KernelAppRegistry:
-    def __init__(self):
+    def __init__(self) -> None:
         self.apps: Dict[str, KernelApp] = {}
 
     def register_app(self, app: KernelApp) -> None:
@@ -116,43 +126,29 @@ def get_apps(self) -> List[KernelApp]:
 
     def get_app_by_name(self, name: str) -> Optional[KernelApp]:
         return self.apps.get(name)
+        
+    def export(self, entrypoint_relpath: str) -> KernelJson:
+        """Export the registry as a KernelJson object"""
+        apps = [app.to_dict() for app in self.get_apps()]
+        return KernelJson(apps=apps, entrypoint=entrypoint_relpath)
 
     def export_json(self, entrypoint_relpath: str) -> str:
         """Export the registry as JSON"""
-        apps = [app.to_dict() for app in self.get_apps()]
-        return json.dumps({"apps": apps, "entrypoint": entrypoint_relpath}, indent=2)
+        kernel_json = self.export(entrypoint_relpath)
+        return json.dumps(kernel_json.__dict__, indent=2)
 
 
 # Create singleton registry for apps
 _app_registry = KernelAppRegistry()
 
-
-# Browser management
-class Browsers:
-    @staticmethod
-    def create(invocation_id: str) -> Browser:
-        """Create a new browser instance"""
-        # TODO: The cdp_ws_url is hardcoded here. This might need to be
-        # dynamically configured or provided by the Kernel platform.
-        return Browser(
-            cdp_ws_url="wss://floral-morning-3s0r8t7x.iad-prod-apiukp-0.onkernel.app:9222/devtools/browser/4dc1cbf6-be0e-4612-bba3-8e399d9638c7"
-        )
-
-
-# Create browser management instance
-browsers = Browsers()
-
-
 # Create a simple function for creating apps
 def App(name: str) -> KernelApp:
     """Create a new Kernel app"""
     return KernelApp(name)
 
-
 # Export the app registry for boot loader
 app_registry = _app_registry
 
-
 # Function to export registry as JSON
 def export_registry(entrypoint_relpath: str) -> str:
     """Export the registry as JSON"""