@malloy-publisher/server 0.0.226 → 0.0.228

package/tests/integration/query_givens/query_givens_authorize.integration.spec.ts

@@ -0,0 +1,121 @@
+/// <reference types="bun-types" />
+
+/**
+ * HTTP E2E for the givens × `#(authorize)` interaction. Malloy is the single
+ * given validator, so on a GATED source a bad given (unknown NAME or wrong-typed
+ * VALUE) is caught inside the authorize probe, which fails closed — surfacing as
+ * a 403, not the 400 the ungated path returns. This suite pins that documented
+ * asymmetry so it stays intentional:
+ *
+ *   - unknown given name        -> 403 (probe can't bind it -> fails closed)
+ *   - authorized + valid givens -> 200 (retargets rows)
+ *   - authorize denies          -> 403
+ *   - valid name, BAD value     -> 403 (probe can't evaluate it -> fails closed)
+ *
+ * On an UNGATED source the same unknown name / bad value are a clean 400 (Malloy
+ * `runtime-given-*` mapped by model.ts) — see query_givens.integration.spec.ts.
+ *
+ * See packages/server/src/service/authorize.ts (evaluateAuthorize, fail-closed).
+ */
+
+import { afterAll, beforeAll, describe, expect, it } from "bun:test";
+import path from "path";
+import { fileURLToPath } from "url";
+import { type RestE2EEnv, startRestE2E } from "../../harness/rest_e2e";
+
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+const ENV_NAME = "query-givens-authz-env";
+const PKG = "query-givens";
+const MODEL = "model.malloy";
+
+type Row = Record<string, unknown>;
+
+describe("givens × authorize on /query (HTTP E2E)", () => {
+   let env: (RestE2EEnv & { stop(): Promise<void> }) | null = null;
+   let baseUrl: string;
+
+   beforeAll(async () => {
+      env = await startRestE2E();
+      baseUrl = env.baseUrl;
+      const fixtureDir = path.resolve(__dirname, "../../fixtures/query-givens");
+      const createRes = await fetch(`${baseUrl}/api/v0/environments`, {
+         method: "POST",
+         headers: { "Content-Type": "application/json" },
+         body: JSON.stringify({
+            name: ENV_NAME,
+            packages: [{ name: PKG, location: fixtureDir }],
+            connections: [],
+         }),
+      });
+      if (!createRes.ok) {
+         throw new Error(
+            `Failed to create test environment (${createRes.status}): ${await createRes.text()}`,
+         );
+      }
+      const deadline = Date.now() + 30_000;
+      while (Date.now() < deadline) {
+         const res = await fetch(
+            `${baseUrl}/api/v0/environments/${ENV_NAME}/packages/${PKG}`,
+         );
+         if (res.ok) break;
+         await new Promise((r) => setTimeout(r, 250));
+      }
+   });
+
+   afterAll(async () => {
+      await fetch(`${baseUrl}/api/v0/environments/${ENV_NAME}`, {
+         method: "DELETE",
+      }).catch(() => {});
+      await env?.stop();
+   });
+
+   const queryGated = (body: Record<string, unknown>) =>
+      fetch(
+         `${baseUrl}/api/v0/environments/${ENV_NAME}/packages/${PKG}/models/${MODEL}/query`,
+         {
+            method: "POST",
+            headers: { "Content-Type": "application/json" },
+            body: JSON.stringify({
+               sourceName: "gated_orders",
+               queryName: "by_given_region",
+               compactJson: true,
+               ...body,
+            }),
+         },
+      );
+
+   it("unknown given name -> 403 on a gated source (authorize probe fails closed)", async () => {
+      // Even with role=admin, the unknown given makes the authorize probe throw
+      // (`runtime-given-unknown`), which the gate treats as not-granting. On an
+      // ungated source the same name is a clean 400 (see query_givens suite).
+      const res = await queryGated({
+         givens: { role: "admin", NOtaGiven: 1 },
+      });
+      expect(res.status).toBe(403);
+   });
+
+   it("authorized caller with valid givens -> 200 and retargets rows", async () => {
+      const res = await queryGated({
+         givens: { role: "admin", target_region: "EU" },
+      });
+      expect(res.status).toBe(200);
+      const body = (await res.json()) as { result: string };
+      const r = JSON.parse(body.result) as Row[];
+      expect(Number(r[0].order_count)).toBe(3);
+   });
+
+   it("authorize deny (non-admin role) -> 403", async () => {
+      const res = await queryGated({ givens: { role: "guest" } });
+      expect(res.status).toBe(403);
+   });
+
+   it("valid given name with a bad value -> 403 on a gated source (fail-closed authorize)", async () => {
+      // The authorize probe binds the supplied givens; a value it can't evaluate
+      // makes the probe throw and the gate denies. On the UNGATED path the same
+      // bad value is a 400 (Malloy at prepare time) — this asymmetry is by design.
+      const res = await queryGated({
+         givens: { role: "admin", min_amount: "not-a-number" },
+      });
+      expect(res.status).toBe(403);
+   });
+});

package/tests/integration/sdk_givens/sdk_givens.integration.spec.ts

@@ -0,0 +1,110 @@
+/// <reference types="bun-types" />
+
+/**
+ * Proves the browser SDK (`packages/server/src/runtime/publisher.js`, served
+ * at GET /sdk/publisher.js) actually puts `givens` on the wire: fetch the
+ * served source, evaluate it in a sandboxed vm context standing in for
+ * `window` (self === top, so the in-iframe/live-reload branches are
+ * inert no-ops), and call `window.Publisher.query(...)` with a `givens`
+ * override against the real HTTP server. Approach used: sandbox-eval via
+ * Node's `vm` module — evaluating the actual runtime rather than just
+ * grepping its source proves the SDK's fetch body really carries `givens`
+ * end-to-end.
+ */
+
+import { afterAll, beforeAll, describe, expect, it } from "bun:test";
+import path from "path";
+import { fileURLToPath } from "url";
+import vm from "vm";
+import { type RestE2EEnv, startRestE2E } from "../../harness/rest_e2e";
+
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+const ENV_NAME = "sdk-givens-env";
+const PKG = "query-givens";
+const MODEL = "model.malloy";
+
+type Row = Record<string, unknown>;
+
+describe("Publisher SDK forwards givens (sandbox-eval HTTP E2E)", () => {
+   let env: (RestE2EEnv & { stop(): Promise<void> }) | null = null;
+   let baseUrl: string;
+
+   beforeAll(async () => {
+      env = await startRestE2E();
+      baseUrl = env.baseUrl;
+      const fixtureDir = path.resolve(__dirname, "../../fixtures/query-givens");
+      const createRes = await fetch(`${baseUrl}/api/v0/environments`, {
+         method: "POST",
+         headers: { "Content-Type": "application/json" },
+         body: JSON.stringify({
+            name: ENV_NAME,
+            packages: [{ name: PKG, location: fixtureDir }],
+            connections: [],
+         }),
+      });
+      if (!createRes.ok) {
+         throw new Error(
+            `Failed to create test environment (${createRes.status}): ${await createRes.text()}`,
+         );
+      }
+      const deadline = Date.now() + 30_000;
+      while (Date.now() < deadline) {
+         const res = await fetch(
+            `${baseUrl}/api/v0/environments/${ENV_NAME}/packages/${PKG}`,
+         );
+         if (res.ok) break;
+         await new Promise((r) => setTimeout(r, 250));
+      }
+   });
+
+   afterAll(async () => {
+      await fetch(`${baseUrl}/api/v0/environments/${ENV_NAME}`, {
+         method: "DELETE",
+      }).catch(() => {});
+      await env?.stop();
+   });
+
+   it("Publisher.query() with a givens override reaches the server and retargets rows", async () => {
+      const sdkRes = await fetch(`${baseUrl}/sdk/publisher.js`);
+      expect(sdkRes.status).toBe(200);
+      const sdkSource = await sdkRes.text();
+
+      // Sandbox stands in for `window`. self === top so the runtime's
+      // in-iframe (postMessage resize) and live-reload (EventSource) branches
+      // are no-ops; document/EventSource are omitted since that code path
+      // never runs for a non-embedded page.
+      const sandbox: Record<string, unknown> = {
+         fetch,
+         location: {
+            pathname: `/environments/${ENV_NAME}/packages/${PKG}/`,
+            origin: baseUrl,
+         },
+         console,
+      };
+      sandbox.self = sandbox;
+      sandbox.top = sandbox;
+      sandbox.window = sandbox;
+
+      const context = vm.createContext(sandbox);
+      vm.runInContext(sdkSource, context, { filename: "publisher.js" });
+
+      const publisher = (sandbox.window as { Publisher: unknown })
+         .Publisher as {
+         query: (
+            modelPath: string,
+            malloyQuery: string | undefined,
+            opts: Record<string, unknown>,
+         ) => Promise<Row[]>;
+      };
+      expect(publisher).toBeDefined();
+
+      const rows = await publisher.query(MODEL, undefined, {
+         sourceName: "orders",
+         queryName: "by_given_region",
+         givens: { target_region: "EU" },
+      });
+
+      expect(rows.length).toBe(1);
+      expect(Number(rows[0].order_count)).toBe(3);
+   });
+});

package/tests/integration/watch-mode/watch_mode.integration.spec.ts

@@ -116,11 +116,6 @@ async function startServer(opts: { watch: boolean }): Promise<TestServer> {
    const port = await getFreePort();
    let mcpPort = await getFreePort();
    while (mcpPort === port) mcpPort = await getFreePort();
-   // The agent MCP server binds its own listener; give it a distinct free port
-   // too, otherwise every spawned child binds the fixed default and collides.
-   let agentMcpPort = await getFreePort();
-   while (agentMcpPort === port || agentMcpPort === mcpPort)
-      agentMcpPort = await getFreePort();
    const baseUrl = `http://127.0.0.1:${port}`;
 
    const env: NodeJS.ProcessEnv = {
@@ -129,7 +124,6 @@ async function startServer(opts: { watch: boolean }): Promise<TestServer> {
       PUBLISHER_HOST: "127.0.0.1",
       PUBLISHER_PORT: String(port),
       MCP_PORT: String(mcpPort),
-      AGENT_MCP_PORT: String(agentMcpPort),
    };
    if (opts.watch) env.PUBLISHER_WATCH = ENV_NAME;
 

package/dxt/malloy_bridge.py

@@ -1,354 +0,0 @@
-#!/usr/bin/env python3
-import sys
-import json
-import urllib.request
-import urllib.parse
-import urllib.error
-import logging
-import time
-import signal
-from typing import Dict, Any, Optional
-
-# Set up logging with more detailed format
-logging.basicConfig(
-    filename='/tmp/malloy_bridge.log', 
-    level=logging.DEBUG, 
-    format='%(asctime)s - %(levelname)s - %(funcName)s:%(lineno)d - %(message)s'
-)
-
-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
-        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, request_id: Optional[Any] = None) -> Dict[str, Any]:
-        """Parse Server-Sent Events response format with improved error handling"""
-        logging.debug(f"Starting SSE parsing for request {request_id}")
-        
-        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": "No data found in response"
-                    },
-                    "id": 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": 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 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,
-                data=data,
-                headers={
-                    'Content-Type': 'application/json',
-                    'Accept': 'application/json, text/event-stream',
-                    'Connection': 'close'  # Don't keep connections open
-                }
-            )
-
-            logging.debug(f"Using timeout of {timeout}s for method {method}")
-            
-            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}"
-            try:
-                error_body = e.read().decode('utf-8')
-                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",
-                "error": {
-                    "code": e.code,
-                    "message": error_message
-                },
-                "id": request_id
-            }
-
-        except urllib.error.URLError as e:
-            elapsed = time.time() - start_time
-            error_msg = f"Connection error: {str(e)}"
-            logging.error(f"URL error for request {request_id} after {elapsed:.2f}s: {error_msg}")
-            return {
-                "jsonrpc": "2.0",
-                "error": {
-                    "code": -32603,
-                    "message": error_msg
-                },
-                "id": request_id
-            }
-
-        except Exception as e:
-            elapsed = time.time() - start_time
-            error_msg = f"Unexpected error: {str(e)}"
-            logging.error(f"Unexpected error for request {request_id} after {elapsed:.2f}s: {error_msg}")
-            return {
-                "jsonrpc": "2.0",
-                "error": {
-                    "code": -32603,
-                    "message": error_msg
-                },
-                "id": request_id
-            }
-
-    def safe_print(self, data):
-        """Print with improved error handling and immediate flushing"""
-        try:
-            output = json.dumps(data)
-            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 = {
-                "jsonrpc": "2.0",
-                "error": {
-                    "code": -32700,
-                    "message": f"Parse error: {str(e)}"
-                },
-                "id": None
-            }
-            self.safe_print(error_response)
-
-        except ValueError as e:
-            logging.error(f"Request validation error: {e}")
-            error_response = {
-                "jsonrpc": "2.0",
-                "error": {
-                    "code": -32600,
-                    "message": f"Invalid Request: {str(e)}"
-                },
-                "id": None
-            }
-            self.safe_print(error_response)
-
-        except Exception as e:
-            logging.error(f"Unexpected error processing request: {e}")
-            error_response = {
-                "jsonrpc": "2.0",
-                "error": {
-                    "code": -32603,
-                    "message": f"Internal error: {str(e)}"
-                },
-                "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__":
-    try:
-        bridge = ImprovedMalloyMCPBridge()
-        bridge.run()
-    except Exception as e:
-        logging.error(f"Failed to start bridge: {e}")
-        sys.exit(1)

package/dxt/manifest.json

@@ -1,22 +0,0 @@
-{
-   "dxt_version": "0.1",
-   "name": "Malloy",
-   "version": "1.0.0",
-   "description": "Connect to Malloy Publisher, allowing you to write & run Malloy data queries.",
-   "author": {
-      "name": "Josh Sacks"
-   },
-   "server": {
-      "type": "python",
-      "entry_point": "malloy_bridge.py",
-      "mcp_config": {
-         "command": "python",
-         "args": ["${__dirname}/malloy_bridge.py"],
-         "env": {
-            "PYTHONPATH": "server/lib"
-         }
-      }
-   },
-   "keywords": ["sql", "malloy", "data", "queries", "charts"],
-   "license": "MIT"
-}