open-edison 0.1.64__py3-none-any.whl → 0.1.75rc1__py3-none-any.whl

src/permissions.py

@@ -53,6 +53,9 @@ class ResourcePermission:
     write_operation: bool = False
     read_private_data: bool = False
     read_untrusted_public_data: bool = False
+    acl: str = "PUBLIC"
+    # Optional metadata fields (ignored by enforcement but accepted from JSON)
+    description: str | None = None
 
 
 @dataclass
@@ -226,43 +229,117 @@ class Permissions:
     def get_tool_permission(self, tool_name: str) -> ToolPermission:
         """Get permission for a specific tool"""
         if tool_name not in self.tool_permissions:
-            raise PermissionsError(f"Tool '{tool_name}' not found in permissions")
+            if tool_name.startswith("builtin_"):
+                log.info(
+                    f"Tool '{tool_name}' not found; returning builtin safe default (enabled, 0 risk)"
+                )
+                return ToolPermission(
+                    enabled=True,
+                    write_operation=False,
+                    read_private_data=False,
+                    read_untrusted_public_data=False,
+                    acl="PUBLIC",
+                )
+            log.warning(
+                f"Tool '{tool_name}' not found in permissions; returning enabled full-trifecta default"
+            )
+            return ToolPermission(
+                enabled=True,
+                write_operation=True,
+                read_private_data=True,
+                read_untrusted_public_data=True,
+                acl="SECRET",
+            )
         return self.tool_permissions[tool_name]
 
     def get_resource_permission(self, resource_name: str) -> ResourcePermission:
         """Get permission for a specific resource"""
         if resource_name not in self.resource_permissions:
-            raise PermissionsError(f"Resource '{resource_name}' not found in permissions")
+            if resource_name.startswith("builtin_"):
+                log.info(
+                    f"Resource '{resource_name}' not found; returning builtin safe default (enabled, 0 risk)"
+                )
+                return ResourcePermission(
+                    enabled=True,
+                    write_operation=False,
+                    read_private_data=False,
+                    read_untrusted_public_data=False,
+                )
+            log.warning(
+                f"Resource '{resource_name}' not found in permissions; returning enabled full-trifecta default"
+            )
+            return ResourcePermission(
+                enabled=True,
+                write_operation=True,
+                read_private_data=True,
+                read_untrusted_public_data=True,
+            )
         return self.resource_permissions[resource_name]
 
     def get_prompt_permission(self, prompt_name: str) -> PromptPermission:
         """Get permission for a specific prompt"""
         if prompt_name not in self.prompt_permissions:
-            raise PermissionsError(f"Prompt '{prompt_name}' not found in permissions")
+            if prompt_name.startswith("builtin_"):
+                log.info(
+                    f"Prompt '{prompt_name}' not found; returning builtin safe default (enabled, 0 risk)"
+                )
+                return PromptPermission(
+                    enabled=True,
+                    write_operation=False,
+                    read_private_data=False,
+                    read_untrusted_public_data=False,
+                    acl="PUBLIC",
+                )
+            log.warning(
+                f"Prompt '{prompt_name}' not found in permissions; returning enabled full-trifecta default"
+            )
+            return PromptPermission(
+                enabled=True,
+                write_operation=True,
+                read_private_data=True,
+                read_untrusted_public_data=True,
+                acl="SECRET",
+            )
         return self.prompt_permissions[prompt_name]
 
     def is_tool_enabled(self, tool_name: str) -> bool:
         """Check if a tool is enabled
         Also checks if the server is enabled"""
         permission = self.get_tool_permission(tool_name)
-        server_name = self.server_name_from_tool_name(tool_name)
-        server_enabled = self.is_server_enabled(server_name)
+        try:
+            server_name = self.server_name_from_tool_name(tool_name)
+            server_enabled = self.is_server_enabled(server_name)
+        except PermissionsError:
+            log.warning(f"Server resolution failed for tool '{tool_name}'; treating as disabled")
+            server_enabled = False
         return permission.enabled and server_enabled
 
     def is_resource_enabled(self, resource_name: str) -> bool:
         """Check if a resource is enabled
         Also checks if the server is enabled"""
         permission = self.get_resource_permission(resource_name)
-        server_name = self.server_name_from_tool_name(resource_name)
-        server_enabled = self.is_server_enabled(server_name)
+        try:
+            server_name = self.server_name_from_tool_name(resource_name)
+            server_enabled = self.is_server_enabled(server_name)
+        except PermissionsError:
+            log.warning(
+                f"Server resolution failed for resource '{resource_name}'; treating as disabled"
+            )
+            server_enabled = False
         return permission.enabled and server_enabled
 
     def is_prompt_enabled(self, prompt_name: str) -> bool:
         """Check if a prompt is enabled
         Also checks if the server is enabled"""
         permission = self.get_prompt_permission(prompt_name)
-        server_name = self.server_name_from_tool_name(prompt_name)
-        server_enabled = self.is_server_enabled(server_name)
+        try:
+            server_name = self.server_name_from_tool_name(prompt_name)
+            server_enabled = self.is_server_enabled(server_name)
+        except PermissionsError:
+            log.warning(
+                f"Server resolution failed for prompt '{prompt_name}'; treating as disabled"
+            )
+            server_enabled = False
         return permission.enabled and server_enabled
 
     @staticmethod

src/server.py

@@ -31,8 +31,11 @@ from loguru import logger as log
 from pydantic import BaseModel, Field
 
 from src import events
-from src.config import Config, MCPServerConfig, clear_json_file_cache
+from src.config import Config, MCPServerConfig, clear_json_file_cache, get_config_json_path
 from src.config import get_config_dir as _get_cfg_dir  # type: ignore[attr-defined]
+from src.mcp_stdio_capture import (
+    install_stdio_client_stderr_capture as _install_stdio_capture,
+)
 from src.middleware.session_tracking import (
     MCPSessionModel,
     create_db_session,
@@ -48,6 +51,9 @@ _security = HTTPBearer()
 _auth_dependency = Depends(_security)
 
 
+_install_stdio_capture()
+
+
 class OpenEdisonProxy:
     """
     Open Edison Single-User MCP Proxy Server
@@ -372,6 +378,9 @@ class OpenEdisonProxy:
         log.info(f"FastAPI management API on {self.host}:{self.port + 1}")
         log.info(f"FastMCP protocol server on {self.host}:{self.port}")
 
+        # Print location of config
+        log.info(f"Config file location: {get_config_json_path()}")
+
         initialize_telemetry()
 
         # Ensure the sessions database exists and has the required schema
@@ -543,11 +552,8 @@ class OpenEdisonProxy:
         warms the lists to ensure subsequent list calls reflect current state.
         """
         try:
-            mcp = self.single_user_mcp
-            # Warm managers so any internal caches are refreshed
-            await mcp._tool_manager.list_tools()  # type: ignore[attr-defined]
-            await mcp._resource_manager.list_resources()  # type: ignore[attr-defined]
-            await mcp._prompt_manager.list_prompts()  # type: ignore[attr-defined]
+            clear_json_file_cache()
+            Permissions.clear_permissions_file_cache()
             return {"status": "ok"}
         except Exception as e:  # noqa: BLE001
             log.error(f"Failed to process permissions-changed: {e}")
@@ -662,14 +668,29 @@ class OpenEdisonProxy:
                 )
 
                 sessions: list[dict[str, Any]] = []
+                has_warned_about_missing_created_at = False
                 for row_model in results:
                     row = cast(Any, row_model)
                     tool_calls_val = row.tool_calls
                     data_access_summary_val = row.data_access_summary
+                    created_at_val = None
+                    if isinstance(data_access_summary_val, dict):
+                        created_at_val = data_access_summary_val.get("created_at")  # type: ignore[assignment]
+                    if (
+                        created_at_val is None
+                        and isinstance(tool_calls_val, list)
+                        and tool_calls_val
+                        and not has_warned_about_missing_created_at
+                    ):
+                        has_warned_about_missing_created_at = True
+                        log.warning(
+                            "created_at is missing, will have sessions with unknown timestamps"
+                        )
                     sessions.append(
                         {
                             "session_id": row.session_id,
                             "correlation_id": row.correlation_id,
+                            "created_at": created_at_val,
                             "tool_calls": tool_calls_val
                             if isinstance(tool_calls_val, list)
                             else [],

src/setup_tui/main.py

@@ -132,16 +132,18 @@ def confirm_configs(configs: list[MCPServerConfig], *, dry_run: bool = False) ->
 
 def confirm_apply_configs(client: CLIENT, *, dry_run: bool = False) -> None:
     if not questionary.confirm(
-        f"We have detected that you have {client.name} installed. Would you like to connect it to open-edison?",
+        f"Would you like to set up Open Edison for {client.name}? (This will modify your MCP configuration. We will make a back up of your current one if you would like to revert.)",
         default=True,
     ).ask():
         return
 
-    export_edison_to(client, dry_run=dry_run)
+    result = export_edison_to(client, dry_run=dry_run)
     if dry_run:
         print(f"[dry-run] Export prepared for {client.name}; no changes written.")
     else:
-        print(f"Successfully set up Open Edison for {client.name}!")
+        print(
+            f"Successfully set up Open Edison for {client.name}! Your previous MCP configuration has been backed up at {result.backup_path}"
+        )
 
 
 def show_manual_setup_screen() -> None:
@@ -235,7 +237,7 @@ def run(*, dry_run: bool = False, skip_oauth: bool = False) -> bool:  # noqa: C9
 
     if len(configs) == 0:
         if not questionary.confirm(
-            "No MCP servers found. Would you like to continue without them?", default=False
+            "No MCP servers found. Would you like to continue without them?", default=True
         ).ask():
             print("Setup aborted. Please configure an MCP client and try again.")
             return False