npm - @malloy-publisher/server - Versions diffs - 0.0.77 → 0.0.78 - Mend

@malloy-publisher/server 0.0.77 → 0.0.78

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (13) hide show

package/dist/app/assets/RenderedResult-BAZuT25g-etaZB-YF.js +2 -0
package/dist/app/assets/index-BKC-ikb3.css +1 -0
package/dist/app/assets/index-BsMlh93-.js +210 -0
package/dist/app/assets/index-BsXDwHRS.js +671 -0
package/dist/app/assets/index-DQrKrnRW.js +432 -0
package/dist/app/assets/index.umd-DaHgfkHn.js +2078 -0
package/dist/app/index.html +2 -2
package/dxt/malloy_bridge.py +149 -69
package/malloy_mcp.dxt +0 -0
package/package.json +1 -1
package/dist/app/assets/RenderedResult-DXlUZo0k-lc5JU6CQ.js +0 -1
package/dist/app/assets/index--hbjs-yl.js +0 -3414
package/dist/app/assets/index-C127D7lT.css +0 -1

package/dist/app/index.html CHANGED Viewed

@@ -12,8 +12,8 @@
          href="https://fonts.googleapis.com/css2?family=Roboto:wght@300;400;500;700&display=swap"
       />
       <title>Malloy Publisher</title>
-     <script type="module" crossorigin src="/assets/index--hbjs-yl.js"></script>
-     <link rel="stylesheet" crossorigin href="/assets/index-C127D7lT.css">
+     <script type="module" crossorigin src="/assets/index-DQrKrnRW.js"></script>
+     <link rel="stylesheet" crossorigin href="/assets/index-BKC-ikb3.css">
    </head>
    <body>
       <div id="root"></div>

package/dxt/malloy_bridge.py CHANGED Viewed

@@ -3,6 +3,7 @@ import sys
 import json
 import urllib.request
 import urllib.parse
+import urllib.error
 import logging
 import time
 import signal
@@ -18,81 +19,126 @@ logging.basicConfig(
 class ImprovedMalloyMCPBridge:
     def __init__(self):
         self.mcp_url = "http://localhost:4040/mcp"
+        # No tool name mapping needed - server already uses underscore format
         # Set stdin/stdout to line buffered mode for better responsiveness
-        sys.stdin.reconfigure(line_buffering=True)
-        sys.stdout.reconfigure(line_buffering=True)
+        try:
+            sys.stdin.reconfigure(line_buffering=True)
+            sys.stdout.reconfigure(line_buffering=True)
+        except AttributeError:
+            # reconfigure not available in older Python versions
+            pass
         # Set up signal handlers for graceful shutdown
         signal.signal(signal.SIGTERM, self.signal_handler)
         signal.signal(signal.SIGINT, self.signal_handler)
         logging.info("Bridge initialized with improved stdio handling")
     def signal_handler(self, signum, frame):
         logging.info(f"Received signal {signum}, shutting down gracefully")
         sys.exit(0)
-    def parse_sse_response(self, response_text: str, request_id: Optional[Any] = None) -> Dict[str, Any]:
+    def parse_sse_response(self, response, request_id: Optional[Any] = None) -> Dict[str, Any]:
         """Parse Server-Sent Events response format with improved error handling"""
-        lines = response_text.strip().split('\n')
-        data_line = None
-        # Look for data line in SSE format
-        for line in lines:
-            if line.startswith('data: '):
-                data_line = line[6:]  # Remove 'data: ' prefix
-                break
+        logging.debug(f"Starting SSE parsing for request {request_id}")
-        # If no SSE format, try parsing the entire response as JSON
-        if not data_line:
-            data_line = response_text.strip()
-        if data_line:
-            try:
-                parsed_data = json.loads(data_line)
-                # Ensure the response has a proper ID
-                if 'id' not in parsed_data or parsed_data['id'] is None:
-                    parsed_data['id'] = request_id
-                logging.debug(f"Successfully parsed response for request {request_id}")
-                return parsed_data
-            except json.JSONDecodeError as e:
-                logging.error(f"JSON decode error for request {request_id}: {e}")
+        try:
+            # Read response with size limit to prevent memory issues
+            max_size = 1024 * 1024  # 1MB limit
+            response_text = ""
+            bytes_read = 0
+            # Read response in chunks to avoid memory issues
+            while True:
+                chunk = response.read(8192)  # 8KB chunks
+                if not chunk:
+                    break
+                bytes_read += len(chunk)
+                if bytes_read > max_size:
+                    logging.warning(f"Response too large ({bytes_read} bytes), truncating")
+                    break
+                response_text += chunk.decode('utf-8')
+            logging.debug(f"Read {bytes_read} bytes from SSE response")
+            lines = response_text.strip().split('\n')
+            data_line = None
+            # Look for data line in SSE format
+            for line in lines:
+                if line.startswith('data: '):
+                    data_line = line[6:]  # Remove 'data: ' prefix
+                    break
+            # If no SSE format, try parsing the entire response as JSON
+            if not data_line:
+                data_line = response_text.strip()
+            if data_line:
+                try:
+                    parsed_data = json.loads(data_line)
+                    # Ensure the response has a proper ID
+                    if 'id' not in parsed_data or parsed_data['id'] is None:
+                        parsed_data['id'] = request_id
+                    logging.debug(f"Successfully parsed response for request {request_id}")
+                    return parsed_data
+                except json.JSONDecodeError as e:
+                    logging.error(f"JSON decode error for request {request_id}: {e}")
+                    logging.error(f"Raw data that failed to parse: {data_line[:200]}...")
+                    return {
+                        "jsonrpc": "2.0",
+                        "error": {
+                            "code": -32603,
+                            "message": f"Failed to parse response: {str(e)}"
+                        },
+                        "id": request_id
+                    }
+            else:
+                logging.error(f"No data found in response for request {request_id}")
                 return {
                     "jsonrpc": "2.0",
                     "error": {
                         "code": -32603,
-                        "message": f"Failed to parse response: {str(e)}"
+                        "message": "No data found in response"
                     },
                     "id": request_id
                 }
-        else:
-            logging.error(f"No data found in response for request {request_id}")
+        except Exception as e:
+            logging.error(f"Error reading SSE response for request {request_id}: {e}")
             return {
                 "jsonrpc": "2.0",
                 "error": {
                     "code": -32603,
-                    "message": "No data found in response"
+                    "message": f"SSE parsing error: {str(e)}"
                 },
                 "id": request_id
             }
     def send_request(self, request: Dict[str, Any]) -> Dict[str, Any]:
         """Send a JSON-RPC request to the Malloy MCP endpoint with improved timeout handling"""
         request_id = request.get("id")
         method = request.get("method", "unknown")
         start_time = time.time()
         logging.debug(f"Sending request {request_id} ({method}) to Malloy server")
+        # Log ALL method calls for debugging
+        logging.info(f"METHOD CALL - Request {request_id}: method='{method}'")
+        if method == "tools/call":
+            tool_name = request.get("params", {}).get("name", "unknown")
+            logging.info(f"TOOL CALL - Request {request_id}: tool_name='{tool_name}'")
+        logging.info(f"FULL REQUEST - {json.dumps(request)}")
         try:
             # Ensure the request has proper structure
             if "jsonrpc" not in request:
                 request["jsonrpc"] = "2.0"
-            # Prepare the request with shorter timeout for responsiveness
+            # Prepare the request with longer timeout for tools/list
+            timeout = 10 if method == "tools/list" else 3
             data = json.dumps(request).encode('utf-8')
             req = urllib.request.Request(
                 self.mcp_url,
@@ -103,15 +149,44 @@ class ImprovedMalloyMCPBridge:
                     'Connection': 'close'  # Don't keep connections open
                 }
             )
+            logging.debug(f"Using timeout of {timeout}s for method {method}")
-            with urllib.request.urlopen(req, timeout=60) as response:
-                response_text = response.read().decode('utf-8')
-                parsed_response = self.parse_sse_response(response_text, request_id)
+            with urllib.request.urlopen(req, timeout=timeout) as response:
+                # Handle SSE response directly from the response object
+                content_type = response.headers.get('Content-Type', '')
+                if 'text/event-stream' in content_type:
+                    logging.debug("Handling SSE response")
+                    parsed_response = self.parse_sse_response(response, request_id)
+                else:
+                    logging.debug("Handling JSON response")
+                    response_text = response.read().decode('utf-8')
+                    try:
+                        parsed_response = json.loads(response_text)
+                        if 'id' not in parsed_response or parsed_response['id'] is None:
+                            parsed_response['id'] = request_id
+                    except json.JSONDecodeError as e:
+                        logging.error(f"Failed to parse JSON response: {e}")
+                        parsed_response = {
+                            "jsonrpc": "2.0",
+                            "error": {
+                                "code": -32603,
+                                "message": f"Invalid JSON response: {str(e)}"
+                            },
+                            "id": request_id
+                        }
+                # Log server response for debugging
+                if "error" in parsed_response:
+                    logging.error(f"SERVER ERROR - Request {request_id} ({method}): {parsed_response}")
+                elif method == "tools/call":
+                    logging.info(f"TOOL CALL - Server response: {str(parsed_response)[:500]}...")
                 elapsed = time.time() - start_time
                 logging.debug(f"Request {request_id} completed in {elapsed:.2f}s")
                 return parsed_response
         except urllib.error.HTTPError as e:
             elapsed = time.time() - start_time
             error_message = f"HTTP {e.code}: {e.reason}"
@@ -120,7 +195,7 @@ class ImprovedMalloyMCPBridge:
                 error_message += f" - {error_body}"
             except:
                 pass
             logging.error(f"HTTP error for request {request_id} after {elapsed:.2f}s: {error_message}")
             return {
                 "jsonrpc": "2.0",
@@ -130,7 +205,7 @@ class ImprovedMalloyMCPBridge:
                 },
                 "id": request_id
             }
         except urllib.error.URLError as e:
             elapsed = time.time() - start_time
             error_msg = f"Connection error: {str(e)}"
@@ -143,7 +218,7 @@ class ImprovedMalloyMCPBridge:
                 },
                 "id": request_id
             }
         except Exception as e:
             elapsed = time.time() - start_time
             error_msg = f"Unexpected error: {str(e)}"
@@ -156,51 +231,56 @@ class ImprovedMalloyMCPBridge:
                 },
                 "id": request_id
             }
     def safe_print(self, data):
         """Print with improved error handling and immediate flushing"""
         try:
             output = json.dumps(data)
-            print(output)
-            sys.stdout.flush()  # Force immediate flush
+            print(output, flush=True)  # Use flush=True for immediate output
             logging.debug(f"Successfully sent response: {len(output)} chars")
         except BrokenPipeError:
             logging.error("Broken pipe error - client disconnected")
             sys.exit(0)
         except Exception as e:
             logging.error(f"Print error: {e}")
             # Don't exit on print errors, just log them
     def process_request(self, line: str) -> None:
         """Process a single request line with improved error handling"""
         try:
             request = json.loads(line)
             request_id = request.get("id", "unknown")
             method = request.get("method", "unknown")
             logging.debug(f"Processing request {request_id}: {method}")
             # Validate required fields
             if not isinstance(request, dict):
                 raise ValueError("Request must be a JSON object")
             if "method" not in request:
                 raise ValueError("Request must have a 'method' field")
+            # Handle notifications/initialized locally (Malloy server doesn't support it)
+            if method == "notifications/initialized":
+                logging.info(f"Handling notifications/initialized locally for request {request_id}")
+                # For notifications, we don't send a response (notifications are one-way)
+                return
             # Ensure ID is present and valid
             if "id" not in request:
                 request["id"] = 1  # Default ID
             elif request["id"] is None:
                 request["id"] = 1  # Replace null with default
             # Send request and get response
             response = self.send_request(request)
             # Send response immediately
             self.safe_print(response)
         except json.JSONDecodeError as e:
             logging.error(f"JSON parse error: {e}")
             error_response = {
@@ -212,7 +292,7 @@ class ImprovedMalloyMCPBridge:
                 "id": None
             }
             self.safe_print(error_response)
         except ValueError as e:
             logging.error(f"Request validation error: {e}")
             error_response = {
@@ -224,7 +304,7 @@ class ImprovedMalloyMCPBridge:
                 "id": None
             }
             self.safe_print(error_response)
         except Exception as e:
             logging.error(f"Unexpected error processing request: {e}")
             error_response = {
@@ -236,33 +316,33 @@ class ImprovedMalloyMCPBridge:
                 "id": None
             }
             self.safe_print(error_response)
     def run(self):
         """Main loop with improved stdin handling"""
         logging.info("Starting main processing loop")
         try:
             # Process stdin line by line with immediate handling
             for line in sys.stdin:
                 line = line.strip()
                 if not line:
                     continue
                 # Process each request immediately
                 self.process_request(line)
         except KeyboardInterrupt:
             logging.info("Received keyboard interrupt, shutting down")
             sys.exit(0)
         except BrokenPipeError:
             logging.info("Broken pipe detected, client disconnected")
             sys.exit(0)
         except Exception as e:
             logging.error(f"Fatal error in main loop: {e}")
             sys.exit(1)
         logging.info("Main loop completed")
 if __name__ == "__main__":

package/malloy_mcp.dxt CHANGED Viewed

Binary file

package/package.json CHANGED Viewed

@@ -1,7 +1,7 @@
 {
    "name": "@malloy-publisher/server",
    "description": "Malloy Publisher Server",
-   "version": "0.0.77",
+   "version": "0.0.78",
    "main": "dist/server.js",
    "bin": {
       "malloy-publisher": "dist/server.js"

package/dist/app/assets/RenderedResult-DXlUZo0k-lc5JU6CQ.js DELETED Viewed

@@ -1 +0,0 @@

- import{r,i as y,j as b}from"./index--hbjs-yl.js";function w({result:o,height:E,isFillElement:c,onSizeChange:f,onDrill:p}){const e=r.useRef(null),[d,h]=r.useState(!1),[m,x]=r.useState(!1),[g,v]=r.useState(!1),n=r.useRef(null),t=r.useRef(null);if(r.useLayoutEffect(()=>{if(e.current&&o&&!m){x(!0),n.current||(n.current=new Promise(s=>{t.current=s}));const u=new y.MalloyRenderer({onClick:p}).createViz();for(;e.current.firstChild;)e.current.removeChild(e.current.firstChild);const l=new MutationObserver(s=>{for(const i of s)if(i.type==="childList"&&i.addedNodes.length>0&&Array.from(i.addedNodes).some(a=>a.nodeType===Node.ELEMENT_NODE)){l.disconnect(),setTimeout(()=>{h(!0),t.current&&(t.current(),t.current=null,n.current=null)},50);break}});if(e.current){l.observe(e.current,{childList:!0,subtree:!0,characterData:!0});try{u.setResult(JSON.parse(o)),u.render(e.current)}catch(s){console.error("Error rendering visualization:",s),l.disconnect(),h(!0),t.current&&(t.current(),t.current=null,n.current=null)}}}},[o,p,m]),r.useEffect(()=>{h(!1),x(!1),n.current=null,t.current=null},[o]),m&&!d&&n.current)throw n.current;return r.useEffect(()=>{if(!e.current||!d)return;const u=e.current,l=()=>{if(u){const a=u.offsetHeight;a>0?f&&f(a):c&&u.firstChild&&(u.firstChild.offsetHeight==0?c(!0):c(!1))}},s=setTimeout(l,100);let i=null;return g||(i=new MutationObserver(l),i.observe(u,{childList:!0,subtree:!0,attributes:!0})),()=>{clearTimeout(s),i?.disconnect()}},[f,o,c,d]),b.jsx("div",{ref:e,style:{width:"100%",height:E?`${E}px`:"100%"}})}export{w as default};