open-edison 0.1.44__tar.gz → 0.1.64__tar.gz

{open_edison-0.1.44 → open_edison-0.1.64}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: open-edison
-Version: 0.1.44
+Version: 0.1.64
 Summary: Open-source MCP security, aggregation, and monitoring. Single-user, self-hosted MCP proxy.
 Author-email: Hugo Berg <hugo@edison.watch>
 License-File: LICENSE
@@ -72,13 +72,7 @@ curl -fsSL https://raw.githubusercontent.com/Edison-Watch/open-edison/main/curl_
 ```
 
 Run locally with uvx: `uvx open-edison`
-
-Optionally, run the setup wizard to import/configure MCP:
-
-```bash
-uv run python -m src.setup_tui.main
-# add --dry-run to preview without writing
-```
+That will run the setup wizard if necessary.
 
 <details>
 <summary>⬇️ Install Node.js/npm (optional for MCP tools)</summary>
@@ -129,19 +123,6 @@ OPEN_EDISON_CONFIG_DIR=~/edison-config open-edison run
 
 </details>
 
-<details>
-<summary>🔄 Import from Cursor/VS Code/Claude Code</summary>
-
-Run the interactive setup wizard to detect clients, import servers, and configure your editor:
-
-```bash
-uv run python -m src.setup_tui.main
-```
-
-Use `--dry-run` to preview without writing.
-
-</details>
-
 <details>
 <summary><img src="https://img.shields.io/badge/Docker-2CA5E0?style=for-the-badge&logo=docker&logoColor=white" alt="Docker"> Run with Docker</summary>
 

{open_edison-0.1.44 → open_edison-0.1.64}/README.md

@@ -47,13 +47,7 @@ curl -fsSL https://raw.githubusercontent.com/Edison-Watch/open-edison/main/curl_
 ```
 
 Run locally with uvx: `uvx open-edison`
-
-Optionally, run the setup wizard to import/configure MCP:
-
-```bash
-uv run python -m src.setup_tui.main
-# add --dry-run to preview without writing
-```
+That will run the setup wizard if necessary.
 
 <details>
 <summary>⬇️ Install Node.js/npm (optional for MCP tools)</summary>
@@ -104,19 +98,6 @@ OPEN_EDISON_CONFIG_DIR=~/edison-config open-edison run
 
 </details>
 
-<details>
-<summary>🔄 Import from Cursor/VS Code/Claude Code</summary>
-
-Run the interactive setup wizard to detect clients, import servers, and configure your editor:
-
-```bash
-uv run python -m src.setup_tui.main
-```
-
-Use `--dry-run` to preview without writing.
-
-</details>
-
 <details>
 <summary><img src="https://img.shields.io/badge/Docker-2CA5E0?style=for-the-badge&logo=docker&logoColor=white" alt="Docker"> Run with Docker</summary>
 

{open_edison-0.1.44 → open_edison-0.1.64}/docs/README.md

@@ -24,7 +24,7 @@ Fast lookup guides:
 Design decisions and technical deep-dives:
 
 - **[Single-User Design](architecture/single_user_design.md)** - Why simplicity over multi-user complexity
-- **[JSON vs Database Config](architecture/config_decisions.md)** - Configuration architecture decisions
+- JSON vs Database config decisions: integrated into the configuration guide
 
 ### 💻 **Development** [`development/`](development/)
 
@@ -40,8 +40,7 @@ Production deployment guides:
 
 - **[Docker Deployment](deployment/docker.md)** - Container-based deployment
 - **[Local Installation](deployment/local.md)** - Local development setup
-- **[Production Setup](deployment/production.md)** - Production configuration
-
+  
 ## 🚀 **Getting Started**
 
 New to Open Edison? Start here:

{open_edison-0.1.44 → open_edison-0.1.64}/docs/architecture/single_user_design.md

@@ -38,17 +38,9 @@ Open Edison deliberately embraces a **single-user design philosophy** that prior
 
 See [configuration.md](../core/configuration.md)
 
-## MCP Server Design
+## MCP Server and API Design
 
-See [mcp_server.md](../core/mcp_server.md)
-
-## Authentication Design
-
-See [authentication.md](../core/authentication.md)
-
-## API Design
-
-See [api.md](../core/api.md)
+See [Project Structure](../core/project_structure.md) and [API Reference](../quick-reference/api_reference.md)
 
 ## Comparison with edison.watch
 

{open_edison-0.1.44 → open_edison-0.1.64}/docs/core/configuration.md

@@ -122,7 +122,7 @@ If `config.json` doesn't exist, Open Edison creates a default configuration:
 ```bash
 make setup
 # or
-python -c "from src.config import Config; Config.create_default().save()"
+python -c "from src.config import Config; cfg=Config(); cfg.create_default(); cfg.save()"
 ```
 
 ### Validation
@@ -133,7 +133,7 @@ Configuration is validated on startup using Python dataclasses:
 from src.config import Config
 
 # Load and validate configuration
-config = Config.load()
+config = Config()
 print(f"Server will run on {config.server.host}:{config.server.port}")
 ```
 
@@ -151,6 +151,36 @@ make run
 
 Later on this will be doable via the API
 
+### Configuration Directory
+
+By default, configuration is loaded from a platform-appropriate config directory. You can override the location using `OPEN_EDISON_CONFIG_DIR`.
+
+Resolution order:
+
+1. `OPEN_EDISON_CONFIG_DIR` environment variable, if set
+2. OS-specific defaults (e.g., `~/Library/Application Support/Open Edison` on macOS, `$XDG_CONFIG_HOME/open-edison` on Linux)
+3. Fallback to `~/.open-edison`
+
+### Telemetry
+
+Open Edison can emit basic telemetry metrics.
+
+```json
+{
+  "telemetry": {
+    "enabled": true,
+    "otlp_endpoint": "https://otel-collector-production-e7a6.up.railway.app/v1/metrics",
+    "headers": { "x-auth": "token" },
+    "export_interval_ms": 60000
+  }
+}
+```
+
+- `enabled`: Toggle telemetry on/off
+- `otlp_endpoint`: Custom OTLP endpoint (defaults to a hosted collector if not set)
+- `headers`: Optional headers for the exporter
+- `export_interval_ms`: Export interval in milliseconds
+
 ## Security Considerations
 
 ### API Key Security

{open_edison-0.1.44 → open_edison-0.1.64}/docs/core/project_structure.md

@@ -10,12 +10,12 @@ Open Edison is a **single-user MCP (Model Context Protocol) proxy server** desig
 
 ```
 open-edison/
-├── main.py                # Entry point - starts the proxy server
+├── main.py                # Entry point - starts both MCP and API servers
 ├── config.json            # JSON configuration (no database needed)
 ├── src/                   # Main source code
-│   ├── server.py          # FastAPI server with authentication
+│   ├── server.py          # FastAPI management API + dashboard wiring
 │   ├── config.py          # JSON configuration management
-│   ├── proxy.py           # MCP server proxy and process management
+│   ├── single_user_mcp.py # FastMCP single-user manager (MCP protocol server)
 │   └── __init__.py        # Package initialization
 ├── tests/                 # Test suite
 │   ├── test_config.py     # Configuration tests
@@ -31,11 +31,11 @@ open-edison/
 
 #### 1. Main Server (`src/server.py`)
 
-- **OpenEdisonProxy**: The core proxy server class
-- **FastAPI integration**: REST API for management (single port: 3000)
-- **Simple authentication**: Bearer token API key authentication
-- **MCP server management**: Start/stop/status of configured MCP servers
-- **Request proxying**: Routes MCP calls to running servers
+- **OpenEdisonProxy**: Orchestrates both servers and routes
+- **Ports**: FastMCP protocol on 3000 (path `/mcp/`), FastAPI management API on 3001
+- **Authentication**: Bearer token API key for management endpoints
+- **MCP management**: Mount/unmount/reinitialize configured MCP servers
+- **Dashboard**: Serves packaged frontend at `/dashboard` on the API server
 
 #### 2. Configuration System (`src/config.py`)
 
@@ -44,12 +44,11 @@ open-edison/
 - **Auto-generation**: Creates default config if missing
 - **Hot reload**: Configuration changes require restart (keeps it simple)
 
-#### 3. MCP Proxy (`src/proxy.py`)
+#### 3. Single-User MCP (`src/single_user_mcp.py`)
 
-- **Process management**: Manages MCP servers as subprocesses
-- **Health monitoring**: Tracks running/stopped server states
-- **Request routing**: Routes MCP requests to appropriate servers
-- **Subprocess isolation**: Each MCP server runs independently
+- **FastMCP integration**: Hosts the MCP protocol server
+- **Server lifecycle**: Initializes and manages configured servers
+- **Mounting**: Supports dynamic mount/unmount via API
 
 ## Data Flow
 
@@ -90,7 +89,7 @@ MCP over streamable HTTP works by sending JSON-RPC messages from the client to t
 
 ## Development Stack
 
-- **Python 3.12+** with **Rye** package management
+- **Python 3.12+** with **uv** package management
 - **FastAPI** for HTTP API endpoints
 - **JSON** for configuration (no database)
 - **Subprocess** for MCP server management
@@ -140,27 +139,28 @@ The project uses a **simple JSON configuration approach** with no database depen
 - **Portable**: Easy to backup and restore
 - **Human Readable**: Easy to edit and understand
 
-## API Endpoints (Port 3000)
+## API Endpoints (Management API on Port 3001)
 
-### Health & Status
+### Public
 
-- **GET /health**: Health check endpoint (no auth required)
-- **GET /mcp/status**: Get status of configured MCP servers
+- **GET /health**: Health check (no auth)
+- **GET /mcp/status**: List configured MCP servers and enabled flags (no auth)
+- **GET /sessions**: Recent session summaries (no auth)
 
-### MCP Server Management
+### Auth required (Bearer: `Authorization: Bearer <api_key>`)
 
-- **POST /mcp/{server_name}/start**: Start a specific MCP server
-- **POST /mcp/{server_name}/stop**: Stop a specific MCP server
+- **GET /mcp/mounted**: List currently mounted servers
+- **POST /mcp/reinitialize**: Reinitialize servers from config
+- **POST /mcp/mount/{server_name}**: Mount a server by name
+- **DELETE /mcp/mount/{server_name}**: Unmount a server by name
+- **GET /mcp/oauth/status** and related `/mcp/oauth/*` endpoints: OAuth status/management for remote servers
 
-### MCP Communication
+### Utilities
 
-- **POST /mcp/call**: Proxy MCP calls to running servers
+- **POST /api/permissions-changed**: Invalidate internal caches after JSON permission updates
+- **GET /events**: Server-Sent Events stream
 
-### Session Management
-
-- **GET /sessions**: Get session logs (placeholder for future SQLite logging)
-
-All endpoints except `/health` require API key authentication via `Authorization: Bearer <api_key>` header.
+MCP protocol server runs on Port 3000 at path `/mcp/`.
 
 ## Getting Started
 
@@ -169,7 +169,7 @@ All endpoints except `/health` require API key authentication via `Authorization
 3. **Configure MCP servers**: Edit `config.json` with your MCP servers
 4. **Run server**: `make run`
 
-The server will start on `localhost:3000` with both HTTP API and MCP proxy functionality.
+The MCP protocol server starts on `localhost:3000/mcp/`, and the management API + dashboard on `http://localhost:3001`.
 
 ## Design Philosophy
 

{open_edison-0.1.44 → open_edison-0.1.64}/docs/core/proxy_usage.md

@@ -16,13 +16,7 @@ make run
 uv run python main.py
 ```
 
-The server starts on `localhost:3001` with:
-
-- **MCP Proxy**: Will proxy MCP calls (future implementation)
-
-And api on `localhost:3001`
-
-- **FastAPI**: REST endpoints for management
+The MCP protocol server runs at `http://localhost:3000/mcp/` and the management API + dashboard are at `http://localhost:3001`.
 
 ### 2. Verify Server Health
 
@@ -40,7 +34,7 @@ curl http://localhost:3001/health
 
 ## HTTP API Reference
 
-All API endpoints require authentication except `/health`:
+Most API endpoints require authentication; public endpoints are noted.
 
 ```bash
 # Authentication header
@@ -69,11 +63,10 @@ curl http://localhost:3001/health
 
 #### GET `/mcp/status`
 
-Get status of all configured MCP servers:
+Get configured MCP servers and their enabled flags (public):
 
 ```bash
-curl -H "Authorization: Bearer your-api-key" \
-     http://localhost:3001/mcp/status
+curl http://localhost:3001/mcp/status
 ```
 
 **Response:**
@@ -81,103 +74,62 @@ curl -H "Authorization: Bearer your-api-key" \
 ```json
 {
   "servers": [
-    {
-      "name": "filesystem",
-      "enabled": true,
-      "running": true
-    },
-    {
-      "name": "github",
-      "enabled": false,
-      "running": false
-    }
+    { "name": "filesystem", "enabled": true },
+    { "name": "github", "enabled": false }
   ]
 }
 ```
 
 ### MCP Server Control
 
-#### POST `/mcp/{server_name}/start`
+#### GET `/mcp/mounted`
 
-Start a specific MCP server:
+List currently mounted servers (auth):
 
 ```bash
-curl -X POST \
-     -H "Authorization: Bearer your-api-key" \
-     http://localhost:3001/mcp/filesystem/start
-```
-
-**Response:**
-
-```json
-{
-  "message": "Server filesystem started successfully"
-}
+curl -H "Authorization: Bearer your-api-key" \
+     http://localhost:3001/mcp/mounted
 ```
 
-#### POST `/mcp/{server_name}/stop`
+#### POST `/mcp/reinitialize`
 
-Stop a specific MCP server:
+Reinitialize servers from the current configuration (auth):
 
 ```bash
-curl -X POST \
-     -H "Authorization: Bearer your-api-key" \
-     http://localhost:3001/mcp/filesystem/stop
+curl -X POST -H "Authorization: Bearer your-api-key" \
+     http://localhost:3001/mcp/reinitialize
 ```
 
-**Response:**
+#### POST `/mcp/mount/{server_name}`
 
-```json
-{
-  "message": "Server filesystem stopped successfully"
-}
-```
+Mount a server by name (auth):
 
-### MCP Communication
+```bash
+curl -X POST -H "Authorization: Bearer your-api-key" \
+     http://localhost:3001/mcp/mount/filesystem
+```
 
-#### POST `/mcp/call`
+#### DELETE `/mcp/mount/{server_name}`
 
-Proxy MCP calls to running servers (currently placeholder):
+Unmount a server by name (auth):
 
 ```bash
-curl -X POST \
-     -H "Authorization: Bearer your-api-key" \
-     -H "Content-Type: application/json" \
-     -d '{"method": "tools/list", "id": 1}' \
-     http://localhost:3001/mcp/call
+curl -X DELETE -H "Authorization: Bearer your-api-key" \
+     http://localhost:3001/mcp/mount/filesystem
 ```
 
-**Response:**
+### MCP Communication
 
-```json
-{
-  "jsonrpc": "2.0",
-  "id": 1,
-  "result": {
-    "message": "MCP request handling not yet implemented",
-    "request": {"method": "tools/list", "id": 1}
-  }
-}
-```
+Use an MCP client to connect to the MCP server at `http://localhost:3000/mcp/` (for example `npx -y mcp-remote http://localhost:3000/mcp/ --http-only`). The management API does not proxy JSON-RPC calls.
 
 ### Session Logging
 
 #### GET `/sessions`
 
-Get session logs (placeholder for future SQLite implementation):
+Get recent MCP session summaries (public):
 
 ```bash
-curl -H "Authorization: Bearer your-api-key" \
-     http://localhost:3001/sessions
-```
-
-**Response:**
-
-```json
-{
-  "sessions": [],
-  "message": "Session logging not yet implemented"
-}
+curl http://localhost:3001/sessions
 ```
 
 ## MCP Server Management
@@ -185,10 +137,9 @@ curl -H "Authorization: Bearer your-api-key" \
 ### Server Lifecycle
 
 1. **Configuration**: Define servers in `config.json`
-2. **Auto-start**: Enabled servers start automatically
-3. **Manual Control**: Start/stop servers via API
-4. **Health Monitoring**: Check server status
-5. **Process Management**: Servers run as subprocesses
+2. **Initialization**: FastMCP initializes servers on startup
+3. **Manual Control**: Mount/unmount servers via API
+4. **Monitoring**: Check mounted servers and status endpoints
 
 ### Process Management
 
@@ -275,23 +226,22 @@ async def manage_mcp_servers():
             health = await resp.json()
             print(f"Server status: {health['status']}")
         
-        # Get MCP server status
+        # Get configured servers
         async with session.get(
-            "http://localhost:3001/mcp/status",
-            headers=headers
+            "http://localhost:3001/mcp/status"
         ) as resp:
             status = await resp.json()
-            print("MCP Servers:")
+            print("Configured servers:")
             for server in status['servers']:
-                print(f"- {server['name']}: {'running' if server['running'] else 'stopped'}")
-        
-        # Start a server
+                print(f"- {server['name']} (enabled={server['enabled']})")
+
+        # Mount a server
         async with session.post(
-            "http://localhost:3001/mcp/filesystem/start",
+            "http://localhost:3001/mcp/mount/filesystem",
             headers=headers
         ) as resp:
             result = await resp.json()
-            print(f"Start result: {result['message']}")
+            print(f"Mount result: {result}")
 
 asyncio.run(manage_mcp_servers())
 ```
@@ -313,20 +263,20 @@ async function manageMCPServers() {
     const health = await axios.get(`${API_BASE}/health`);
     console.log('Server status:', health.data.status);
     
-    // Get server status
-    const status = await axios.get(`${API_BASE}/mcp/status`, { headers });
-    console.log('MCP Servers:');
+    // Get configured servers
+    const status = await axios.get(`${API_BASE}/mcp/status`);
+    console.log('Configured servers:');
     status.data.servers.forEach(server => {
-      console.log(`- ${server.name}: ${server.running ? 'running' : 'stopped'}`);
+      console.log(`- ${server.name} (enabled=${server.enabled})`);
     });
-    
-    // Start filesystem server
-    const start = await axios.post(
-      `${API_BASE}/mcp/filesystem/start`, 
+
+    // Mount filesystem server
+    const mount = await axios.post(
+      `${API_BASE}/mcp/mount/filesystem`, 
       {}, 
       { headers }
     );
-    console.log('Start result:', start.data.message);
+    console.log('Mount result:', mount.data);
     
   } catch (error) {
     console.error('Error:', error.response?.data || error.message);
@@ -359,13 +309,13 @@ curl -s "$BASE_URL/health" | jq .
 echo "Getting MCP server status..."
 api_call "$BASE_URL/mcp/status" | jq .
 
-# Start filesystem server
-echo "Starting filesystem server..."
-api_call -X POST "$BASE_URL/mcp/filesystem/start" | jq .
+# Mount filesystem server
+echo "Mounting filesystem server..."
+api_call -X POST "$BASE_URL/mcp/mount/filesystem" | jq .
 
-# Check status again
-echo "Checking status after start..."
-api_call "$BASE_URL/mcp/status" | jq '.servers[] | select(.name=="filesystem")'
+# Check mounted
+echo "Getting mounted servers..."
+api_call "$BASE_URL/mcp/mounted" | jq .
 ```
 
 ## Use Cases
@@ -396,17 +346,17 @@ import aiohttp
 async def enable_work_servers():
     headers = {"Authorization": "Bearer work-api-key"}
     
-    # Start work-related servers
+    # Mount work-related servers
     work_servers = ["github", "documents", "slack-integration"]
     
     async with aiohttp.ClientSession() as session:
         for server in work_servers:
             async with session.post(
-                f"http://localhost:3001/mcp/{server}/start",
+                f"http://localhost:3001/mcp/mount/{server}",
                 headers=headers
             ) as resp:
                 result = await resp.json()
-                print(f"Started {server}: {result['message']}")
+                print(f"Mounted {server}: {result}")
 ```
 
 ### 3. Server Health Monitoring
@@ -430,10 +380,10 @@ async def monitor_servers():
                 status = await resp.json()
                 
                 for server in status['servers']:
-                    if server['enabled'] and not server['running']:
-                        print(f"Restarting {server['name']}...")
+                    # Example: ensure critical servers are mounted
+                    if server['enabled'] and server['name'] == 'filesystem':
                         await session.post(
-                            f"http://localhost:3001/mcp/{server['name']}/start",
+                            f"http://localhost:3001/mcp/mount/{server['name']}",
                             headers=headers
                         )
         
@@ -452,8 +402,8 @@ asyncio.run(monitor_servers())
    # Check if command exists
    which uvx
    
-   # Check configuration
-   python -c "from src.config import config; print(config.mcp_servers[0].command)"
+   # Check configuration load
+   python -c "from src.config import Config; print(Config().mcp_servers[0].command)"
    
    # Check logs
    tail -f server.log
@@ -485,9 +435,9 @@ asyncio.run(monitor_servers())
    # Check server status
    curl -H "Authorization: Bearer api-key" http://localhost:3001/mcp/status
    
-   # Restart crashed server
+   # Remount server by name
    curl -X POST -H "Authorization: Bearer api-key" \
-        http://localhost:3001/mcp/server-name/start
+        http://localhost:3001/mcp/mount/server-name
    ```
 
 ### Debug Mode

{open_edison-0.1.44 → open_edison-0.1.64}/docs/deployment/docker.md

@@ -16,7 +16,10 @@ make docker_build
 make docker_run
 ```
 
-The server will be available at `http://localhost:3000`.
+Services:
+
+- MCP protocol server: `http://localhost:3000/mcp/`
+- Management API + dashboard: `http://localhost:3001`
 
 ## Manual Docker Commands
 

{open_edison-0.1.44 → open_edison-0.1.64}/docs/deployment/local.md

@@ -58,7 +58,7 @@ pip install -r requirements.lock
 make setup
 
 # Or manually
-python -c "from src.config import Config; Config.create_default().save()"
+python -c "from src.config import Config; cfg=Config(); cfg.create_default(); cfg.save()"
 ```
 
 ### 4. Configure
@@ -104,8 +104,8 @@ make sync
 # Setup configuration
 make setup
 
-# Run development server (with auto-reload if supported)
-make dev
+# Run the server
+make run
 
 # Run tests
 make test
@@ -124,12 +124,11 @@ make ci
 # Start server
 make run
 
-# Health check
-curl http://localhost:3000/health
+# Health check (API)
+curl http://localhost:3001/health
 
-# Check MCP server status (requires API key)
-curl -H "Authorization: Bearer your-api-key" \
-     http://localhost:3000/mcp/status
+# Check MCP server status (public)
+curl http://localhost:3001/mcp/status
 ```
 
 ## Configuration