auto-coder-web 0.1.59__tar.gz → 0.1.61__tar.gz

{auto_coder_web-0.1.59 → auto_coder_web-0.1.61}/PKG-INFO

@@ -1,13 +1,13 @@
 Metadata-Version: 2.1
 Name: auto_coder_web
-Version: 0.1.59
+Version: 0.1.61
 Summary: auto-coder.web: A Python Project
 Author: allwefantasy
 Classifier: Programming Language :: Python :: 3.9
 Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.11
 Description-Content-Type: text/markdown
-Requires-Dist: auto-coder>=0.1.331
+Requires-Dist: auto-coder>=0.1.333
 Requires-Dist: aiofiles
 Requires-Dist: psutil
 Requires-Dist: sse-starlette

{auto_coder_web-0.1.59 → auto_coder_web-0.1.61}/src/auto_coder_web/proxy.py

@@ -19,7 +19,7 @@ import sys
 from auto_coder_web.terminal import terminal_manager
 from autocoder.common import AutoCoderArgs
 from auto_coder_web.auto_coder_runner_wrapper import AutoCoderRunnerWrapper
-from auto_coder_web.routers import todo_router, settings_router, auto_router, commit_router, chat_router, coding_router, index_router, config_router, upload_router, rag_router
+from auto_coder_web.routers import todo_router, settings_router, auto_router, commit_router, chat_router, coding_router, index_router, config_router, upload_router, rag_router, editable_preview_router
 from auto_coder_web.expert_routers import history_router
 from auto_coder_web.common_router import completions_router, file_router, auto_coder_conf_router, chat_list_router, file_group_router, model_router, compiler_router
 from rich.console import Console
@@ -100,6 +100,7 @@ class ProxyServer:
         self.app.include_router(config_router.router)
         self.app.include_router(upload_router.router)
         self.app.include_router(rag_router.router)
+        self.app.include_router(editable_preview_router.router)
         # self.app.include_router(rag_router.router)
 
         @self.app.on_event("shutdown")

auto_coder_web-0.1.61/src/auto_coder_web/routers/editable_preview_router.py

@@ -0,0 +1,202 @@
+import logging
+from pydantic import BaseModel
+import requests
+from fastapi import APIRouter, HTTPException, Request, Query, Body
+from fastapi.responses import HTMLResponse
+from bs4 import BeautifulSoup
+from urllib.parse import urljoin, urlparse
+import aiofiles
+from pathlib import Path
+import json
+from datetime import datetime
+import uuid
+from loguru import logger as global_logger
+
+logger = global_logger.bind(name="editable_preview")
+router = APIRouter()
+
+# --- Configuration ---
+BRIDGE_SCRIPT_PATH = "/bridge.js"  # Path where the frontend serves bridge.js
+SAVED_PREVIEWS_DIR = Path(".auto-coder/auto-coder.web/editable-previews")
+SAVED_PREVIEWS_DIR.mkdir(parents=True, exist_ok=True)
+# --- End Configuration ---
+
+
+def resolve_url(base_url: str, relative_url: str) -> str:
+    """Resolves a relative URL against a base URL."""
+    try:
+        return urljoin(base_url, relative_url)
+    except ValueError:
+        # Handle cases where relative_url might be invalid
+        return relative_url
+
+def rewrite_html_resources(soup: BeautifulSoup, base_url: str, proxy_base: str):
+    """Rewrites relative URLs in common HTML tags to absolute URLs or proxy URLs."""
+    tags_attributes = {
+        'a': 'href',
+        'link': 'href',
+        'script': 'src',
+        'img': 'src',
+        'iframe': 'src',
+        'form': 'action',
+        # Add other tags/attributes as needed
+    }
+
+    for tag_name, attr_name in tags_attributes.items():
+        for tag in soup.find_all(tag_name):
+            attr_value = tag.get(attr_name)
+            if attr_value:
+                # Resolve relative URLs relative to the original page's base URL
+                absolute_url = resolve_url(base_url, attr_value)
+                
+                # Optionally, rewrite to go through proxy (more complex, might break things)
+                # For simplicity now, just make them absolute to original domain
+                # proxy_url = f"{proxy_base}?url={absolute_url}" # Example proxy rewrite
+                # tag[attr_name] = proxy_url
+                tag[attr_name] = absolute_url # Keep original absolute for now
+
+    # Special handling for inline styles with url()
+    for tag in soup.find_all(style=True):
+        # Basic url() rewriting - might need a more robust CSS parser for complex cases
+        style_content = tag['style']
+        # This regex is basic, might need refinement
+        import re
+        def replace_url(match):
+            url = match.group(1).strip("'\"")
+            absolute_url = resolve_url(base_url, url)
+            return f"url('{absolute_url}')"
+
+        tag['style'] = re.sub(r"url\((.*?)\)", replace_url, style_content)
+
+    # Consider rewriting srcset for images as well if needed
+
+@router.get("/api/editable-preview/proxy", response_class=HTMLResponse)
+async def proxy_external_url(request: Request, url: str = Query(...)):
+    """
+    Fetches an external URL, injects a bridge script, and returns the HTML.
+    Handles basic resource URL rewriting.
+    """
+    if not url or not url.startswith(('http://', 'https://')):
+        raise HTTPException(status_code=400, detail="Invalid or missing URL parameter")
+
+    try:
+        headers = {
+            # Mimic a browser request
+            'User-Agent': request.headers.get('user-agent', 'Mozilla/5.0'),
+            'Accept': 'text/html,application/xhtml+xml,application/xml;q=0.9,image/webp,*/*;q=0.8',
+            'Accept-Language': 'en-US,en;q=0.5',
+            'Referer': urlparse(url).scheme + "://" + urlparse(url).netloc # Set referer to target domain
+        }
+        response = requests.get(url, headers=headers, timeout=15, allow_redirects=True)
+        response.raise_for_status() # Raise HTTPError for bad responses (4xx or 5xx)
+
+        # Check content type
+        content_type = response.headers.get('content-type', '').lower()
+        if 'text/html' not in content_type:
+            logger.warning(f"Proxied URL {url} returned non-HTML content-type: {content_type}")
+            # Return as is if not HTML, or raise error? Decide based on desired behavior.
+            # For now, let's try parsing anyway, but log a warning.
+            # raise HTTPException(status_code=400, detail=f"URL did not return HTML content. Content-Type: {content_type}")
+
+        # Parse HTML content
+        soup = BeautifulSoup(response.text, 'html.parser')
+
+        # --- Inject Bridge Script ---
+        bridge_script_tag = soup.new_tag("script")
+        bridge_script_tag["src"] = BRIDGE_SCRIPT_PATH
+        bridge_script_tag["defer"] = True # Load after HTML parsing but before DOMContentLoaded
+
+        # Try injecting into <head>, fallback to <body>
+        head = soup.find('head')
+        if head:
+            head.append(bridge_script_tag)
+        else:
+            body = soup.find('body')
+            if body:
+                body.append(bridge_script_tag)
+            else:
+                # If no head or body, append to the root (less ideal)
+                soup.append(bridge_script_tag)
+        # --- End Injection ---
+
+        # --- Rewrite Resource URLs ---
+        # Get the final URL after potential redirects
+        final_url = response.url
+        # Define the base for our proxy endpoint (needed if we decide to proxy resources)
+        proxy_base_url = str(request.base_url) + "api/editable-preview/proxy"
+        rewrite_html_resources(soup, final_url, proxy_base_url)
+        # --- End Rewriting ---
+
+        # Return modified HTML
+        modified_html = str(soup)
+
+        # Prepare response, try to remove X-Frame-Options
+        resp_headers = dict(response.headers)
+        # Remove security headers that prevent framing (use with caution)
+        resp_headers.pop('X-Frame-Options', None)
+        resp_headers.pop('Content-Security-Policy', None)
+        # Remove Content-Length header
+        resp_headers.pop('Content-Length', None)
+        # Ensure correct content type
+        resp_headers['Content-Type'] = 'text/html; charset=utf-8' # Force UTF-8
+
+        return HTMLResponse(content=modified_html, headers=resp_headers)
+
+    except requests.exceptions.Timeout:
+        raise HTTPException(status_code=504, detail=f"Timeout while fetching URL: {url}")
+    except requests.exceptions.RequestException as e:
+        logger.error(f"Error fetching URL {url}: {e}")
+        raise HTTPException(status_code=502, detail=f"Failed to fetch URL: {url}. Error: {str(e)}")
+    except Exception as e:
+        logger.error(f"Error processing proxy request for {url}: {e}", exc_info=True)
+        raise HTTPException(status_code=500, detail=f"Internal server error processing URL: {url}")
+
+
+class SavePreviewRequest(BaseModel):
+    url: str
+    html_content: str
+
+@router.post("/api/editable-preview/save")
+async def save_edited_preview(payload: SavePreviewRequest = Body(...)):
+    """Saves the edited HTML content for a given URL."""
+    try:
+        url = payload.url
+        html_content = payload.html_content
+
+        if not url or not html_content:
+            raise HTTPException(status_code=400, detail="Missing URL or HTML content")
+
+        # Generate a unique filename or use a hash of the URL
+        parsed_url = urlparse(url)
+        # Sanitize filename (basic example)
+        filename_base = f"{parsed_url.netloc}_{parsed_url.path}".replace('/', '_').replace('.', '_')
+        filename_base = "".join(c for c in filename_base if c.isalnum() or c in ('_', '-')).rstrip('_')[:100] # Limit length
+        
+        save_id = str(uuid.uuid4())
+        timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
+        filename = f"{filename_base}_{timestamp}_{save_id}.html"
+        filepath = SAVED_PREVIEWS_DIR / filename
+
+        metadata = {
+            "original_url": url,
+            "saved_at": datetime.now().isoformat(),
+            "save_id": save_id,
+            "filename": filename
+        }
+        meta_filepath = SAVED_PREVIEWS_DIR / f"{filename}.meta.json"
+
+
+        async with aiofiles.open(filepath, mode='w', encoding='utf-8') as f:
+            await f.write(html_content)
+
+        async with aiofiles.open(meta_filepath, mode='w', encoding='utf-8') as f:
+            await f.write(json.dumps(metadata, indent=2))
+
+        logger.info(f"Saved edited preview for URL '{url}' to '{filepath}'")
+        return {"status": "success", "save_id": save_id, "filename": filename}
+
+    except HTTPException:
+        raise # Re-raise HTTP exceptions
+    except Exception as e:
+        logger.error(f"Error saving edited preview for URL '{payload.url}': {e}", exc_info=True)
+        raise HTTPException(status_code=500, detail="Failed to save edited preview")

auto_coder_web-0.1.61/src/auto_coder_web/routers/mcp_router.py

@@ -0,0 +1,188 @@
+import asyncio
+import json
+import os
+from fastapi import APIRouter, HTTPException, Request, Depends
+from pydantic import BaseModel, Field
+from typing import Dict, Any, Optional, List
+from autocoder.common.mcp_server import (
+    get_mcp_server, 
+    McpInstallRequest, 
+    McpRemoveRequest, 
+    McpListRequest, 
+    McpListRunningRequest, 
+    McpRefreshRequest, 
+    McpServerInfoRequest,
+    McpResponse
+)
+from autocoder.common.printer import Printer # For messages
+from autocoder.chat_auto_coder_lang import get_message_with_format # For formatted messages
+from loguru import logger
+from byzerllm.utils.langutil import asyncfy_with_semaphore
+
+# Use asyncfy_with_semaphore to wrap the synchronous send_request method
+async_send_request = asyncfy_with_semaphore(get_mcp_server().send_request, max_workers=5) 
+
+router = APIRouter()
+printer = Printer() # Initialize printer for messages
+
+# --- Pydantic Models for Requests ---
+
+class McpAddRequest(BaseModel):
+    server_config: str = Field(..., description="Server configuration string (command-line style or JSON)")
+
+class McpRemoveRequestModel(BaseModel):
+    server_name: str = Field(..., description="Name of the MCP server to remove")
+
+class McpRefreshRequestModel(BaseModel):
+    server_name: Optional[str] = Field(None, description="Name of the MCP server to refresh (optional, refreshes all if None)")
+
+class McpInfoRequestModel(BaseModel):
+    # Assuming model and product_mode might come from global config or request context later
+    # For now, let's make them optional or derive them if possible
+    model: Optional[str] = None
+    product_mode: Optional[str] = None # Example: "lite", "pro"
+
+# --- Helper Function to Handle MCP Responses ---
+
+async def handle_mcp_response(request: Any, success_key: str, error_key: str, **kwargs) -> Dict[str, Any]:
+    """Handles sending request to MCP server and formatting the response."""
+    try:
+        response: McpResponse = await async_send_request(request)
+        if response.error:
+            logger.error(f"MCP Error ({error_key}): {response.error}")
+            # Use get_message_with_format if available, otherwise use the raw error
+            error_message = response.error
+            try:
+                # Attempt to format the error message if a key is provided
+                formatted_error = get_message_with_format(error_key, error=response.error)
+                if formatted_error: # Check if formatting was successful
+                    error_message = formatted_error
+            except Exception: # Catch potential errors during formatting
+                pass # Stick with the original error message
+            raise HTTPException(status_code=400, detail=error_message)
+        else:
+            # Use get_message_with_format for success message if available
+            success_message = response.result
+            try:
+                formatted_success = get_message_with_format(success_key, result=response.result, **kwargs)
+                if formatted_success: # Check if formatting was successful
+                    success_message = formatted_success
+            except Exception:
+                 pass # Stick with the original result message
+            return {"status": "success", "message": success_message, "data": response.result} # Include raw data too
+    except HTTPException as http_exc:
+        raise http_exc # Re-raise HTTPException
+    except Exception as e:
+        logger.error(f"Unexpected error during MCP request ({error_key}): {str(e)}")
+        raise HTTPException(status_code=500, detail=f"Internal server error: {str(e)}")
+
+# --- API Endpoints ---
+
+@router.post("/api/mcp/add")
+async def add_mcp_server(request: McpAddRequest):
+    """
+    Adds or updates an MCP server configuration.
+    Accepts command-line style args or a JSON string.
+    """
+    mcp_request = McpInstallRequest(server_name_or_config=request.server_config)
+    return await handle_mcp_response(
+        mcp_request,
+        success_key="mcp_install_success",
+        error_key="mcp_install_error",
+        result=request.server_config # Pass original config for success message formatting
+    )
+
+@router.post("/api/mcp/remove")
+async def remove_mcp_server(request: McpRemoveRequestModel):
+    """Removes an MCP server configuration by name."""
+    mcp_request = McpRemoveRequest(server_name=request.server_name)
+    return await handle_mcp_response(
+        mcp_request,
+        success_key="mcp_remove_success",
+        error_key="mcp_remove_error",
+        result=request.server_name # Pass server name for success message formatting
+    )
+
+@router.get("/api/mcp/list")
+async def list_mcp_servers():
+    """Lists all available built-in and external MCP servers."""
+    mcp_request = McpListRequest()
+    # Specific handling for list as the result is the data itself
+    try:
+        response: McpResponse = await async_send_request(mcp_request)
+        if response.error:
+            logger.error(f"MCP Error (mcp_list_builtin_error): {response.error}")
+            error_message = get_message_with_format("mcp_list_builtin_error", error=response.error) or response.error
+            raise HTTPException(status_code=400, detail=error_message)
+        else:
+            # Split the result string into a list for better JSON representation
+            server_list = response.result.strip().split('\n') if response.result else []
+            return {"status": "success", "servers": server_list}
+    except HTTPException as http_exc:
+        raise http_exc
+    except Exception as e:
+        logger.error(f"Unexpected error during MCP list request: {str(e)}")
+        raise HTTPException(status_code=500, detail=f"Internal server error: {str(e)}")
+
+
+@router.get("/api/mcp/list_running")
+async def list_running_mcp_servers():
+    """Lists all currently running/connected MCP servers."""
+    mcp_request = McpListRunningRequest()
+    # Specific handling for list_running
+    try:
+        response: McpResponse = await async_send_request(mcp_request)
+        if response.error:
+            logger.error(f"MCP Error (mcp_list_running_error): {response.error}")
+            error_message = get_message_with_format("mcp_list_running_error", error=response.error) or response.error
+            raise HTTPException(status_code=400, detail=error_message)
+        else:
+             # Split the result string into a list
+            running_server_list = response.result.strip().split('\n') if response.result else []
+            # Clean up list (remove potential leading hyphens/spaces)
+            cleaned_list = [s.strip().lstrip('-').strip() for s in running_server_list if s.strip()]
+            return {"status": "success", "running_servers": cleaned_list}
+    except HTTPException as http_exc:
+        raise http_exc
+    except Exception as e:
+        logger.error(f"Unexpected error during MCP list_running request: {str(e)}")
+        raise HTTPException(status_code=500, detail=f"Internal server error: {str(e)}")
+
+@router.post("/api/mcp/refresh")
+async def refresh_mcp_connections(request: McpRefreshRequestModel):
+    """Refreshes connections to MCP servers (all or a specific one)."""
+    mcp_request = McpRefreshRequest(name=request.server_name)
+    return await handle_mcp_response(
+        mcp_request,
+        success_key="mcp_refresh_success",
+        error_key="mcp_refresh_error"
+    )
+
+@router.get("/api/mcp/info")
+async def get_mcp_server_info(model: Optional[str] = None, product_mode: Optional[str] = None):
+    """Gets detailed information about connected MCP servers."""
+    # TODO: Determine how to get model/product_mode - from app state, global config, or request?
+    # Using optional query params for now.
+    mcp_request = McpServerInfoRequest(model=model, product_mode=product_mode)
+    # Specific handling for info
+    try:
+        response: McpResponse = await async_send_request(mcp_request)
+        if response.error:
+            logger.error(f"MCP Error (mcp_server_info_error): {response.error}")
+            error_message = get_message_with_format("mcp_server_info_error", error=response.error) or response.error
+            raise HTTPException(status_code=400, detail=error_message)
+        else:
+            # The result is likely a markdown string or complex structure. Return as is.
+            return {"status": "success", "info": response.result}
+    except HTTPException as http_exc:
+        raise http_exc
+    except Exception as e:
+        logger.error(f"Unexpected error during MCP info request: {str(e)}")
+        raise HTTPException(status_code=500, detail=f"Internal server error: {str(e)}")
+
+# Potentially add endpoints for direct tool calls or resource access if needed in the future
+# @router.post("/api/mcp/call_tool")
+# async def call_mcp_tool(...): ...
+
+# @router.get("/api/mcp/read_resource")
+# async def read_mcp_resource(...): ...

auto_coder_web-0.1.61/src/auto_coder_web/version.py

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

auto_coder_web-0.1.59/src/auto_coder_web/web/assets/cssMode-l2jjsqtW.js → auto_coder_web-0.1.61/src/auto_coder_web/web/assets/cssMode-DzQL_FdL.js

@@ -1,4 +1,4 @@
-import{m as et}from"./index-KrCRB6ZK.js";/*!-----------------------------------------------------------------------------
+import{m as et}from"./index-kyBHOjJU.js";/*!-----------------------------------------------------------------------------
  * Copyright (c) Microsoft Corporation. All rights reserved.
  * Version: 0.52.2(404545bded1df6ffa41ea0af4e8ddb219018c6c1)
  * Released under the MIT license

auto_coder_web-0.1.59/src/auto_coder_web/web/assets/freemarker2-S4tCPD6N.js → auto_coder_web-0.1.61/src/auto_coder_web/web/assets/freemarker2-B6aemwaC.js

@@ -1,4 +1,4 @@
-import{m as f}from"./index-KrCRB6ZK.js";/*!-----------------------------------------------------------------------------
+import{m as f}from"./index-kyBHOjJU.js";/*!-----------------------------------------------------------------------------
  * Copyright (c) Microsoft Corporation. All rights reserved.
  * Version: 0.52.2(404545bded1df6ffa41ea0af4e8ddb219018c6c1)
  * Released under the MIT license

auto_coder_web-0.1.59/src/auto_coder_web/web/assets/handlebars-Wil-azPx.js → auto_coder_web-0.1.61/src/auto_coder_web/web/assets/handlebars-C2cM4xS8.js

@@ -1,4 +1,4 @@
-import{m as l}from"./index-KrCRB6ZK.js";/*!-----------------------------------------------------------------------------
+import{m as l}from"./index-kyBHOjJU.js";/*!-----------------------------------------------------------------------------
  * Copyright (c) Microsoft Corporation. All rights reserved.
  * Version: 0.52.2(404545bded1df6ffa41ea0af4e8ddb219018c6c1)
  * Released under the MIT license

auto_coder_web-0.1.59/src/auto_coder_web/web/assets/html-BHkmBm1e.js → auto_coder_web-0.1.61/src/auto_coder_web/web/assets/html-Da2X74rm.js

@@ -1,4 +1,4 @@
-import{m as s}from"./index-KrCRB6ZK.js";/*!-----------------------------------------------------------------------------
+import{m as s}from"./index-kyBHOjJU.js";/*!-----------------------------------------------------------------------------
  * Copyright (c) Microsoft Corporation. All rights reserved.
  * Version: 0.52.2(404545bded1df6ffa41ea0af4e8ddb219018c6c1)
  * Released under the MIT license

auto_coder_web-0.1.59/src/auto_coder_web/web/assets/htmlMode-BafxlJGB.js → auto_coder_web-0.1.61/src/auto_coder_web/web/assets/htmlMode-Y3eBAl3y.js

@@ -1,4 +1,4 @@
-import{m as lt}from"./index-KrCRB6ZK.js";/*!-----------------------------------------------------------------------------
+import{m as lt}from"./index-kyBHOjJU.js";/*!-----------------------------------------------------------------------------
  * Copyright (c) Microsoft Corporation. All rights reserved.
  * Version: 0.52.2(404545bded1df6ffa41ea0af4e8ddb219018c6c1)
  * Released under the MIT license