@sylphx/lens-server 4.1.3 → 4.1.5

package/dist/index.js

@@ -1045,6 +1045,107 @@ class LensServerImpl {
         headers: baseHeaders
       });
     }
+    if (request.method === "GET" && pathname.endsWith("/__lens/sse")) {
+      const path = url.searchParams.get("path");
+      if (!path) {
+        const encoder = new TextEncoder;
+        const errorStream = new ReadableStream({
+          start(controller) {
+            const data = `event: error
+data: ${JSON.stringify({ error: "Missing path parameter" })}
+
+`;
+            controller.enqueue(encoder.encode(data));
+            controller.close();
+          }
+        });
+        return new Response(errorStream, {
+          headers: {
+            "Content-Type": "text/event-stream",
+            "Cache-Control": "no-cache",
+            Connection: "keep-alive"
+          }
+        });
+      }
+      const inputParam = url.searchParams.get("input");
+      let input;
+      if (inputParam) {
+        try {
+          input = JSON.parse(inputParam);
+        } catch {
+          const encoder = new TextEncoder;
+          const errorStream = new ReadableStream({
+            start(controller) {
+              const data = `event: error
+data: ${JSON.stringify({ error: "Invalid input JSON" })}
+
+`;
+              controller.enqueue(encoder.encode(data));
+              controller.close();
+            }
+          });
+          return new Response(errorStream, {
+            headers: {
+              "Content-Type": "text/event-stream",
+              "Cache-Control": "no-cache",
+              Connection: "keep-alive"
+            }
+          });
+        }
+      }
+      const self = this;
+      const stream = new ReadableStream({
+        start(controller) {
+          const encoder = new TextEncoder;
+          try {
+            const result = self.execute({ path, input });
+            if (result && typeof result === "object" && "subscribe" in result) {
+              const observable = result;
+              const subscription = observable.subscribe({
+                next: (value) => {
+                  const data = `data: ${JSON.stringify(value)}
+
+`;
+                  controller.enqueue(encoder.encode(data));
+                },
+                error: (err) => {
+                  const data = `event: error
+data: ${JSON.stringify({ error: err.message })}
+
+`;
+                  controller.enqueue(encoder.encode(data));
+                  controller.close();
+                },
+                complete: () => {
+                  controller.close();
+                }
+              });
+              if (request.signal) {
+                request.signal.addEventListener("abort", () => {
+                  subscription.unsubscribe();
+                  controller.close();
+                });
+              }
+            }
+          } catch (execError) {
+            const errMsg = execError instanceof Error ? execError.message : "Internal error";
+            const data = `event: error
+data: ${JSON.stringify({ error: errMsg })}
+
+`;
+            controller.enqueue(encoder.encode(data));
+            controller.close();
+          }
+        }
+      });
+      return new Response(stream, {
+        headers: {
+          "Content-Type": "text/event-stream",
+          "Cache-Control": "no-cache",
+          Connection: "keep-alive"
+        }
+      });
+    }
     if (request.method === "POST") {
       let body;
       try {

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@sylphx/lens-server",
-	"version": "4.1.3",
+	"version": "4.1.5",
 	"description": "Server runtime for Lens API framework",
 	"type": "module",
 	"main": "./dist/index.js",

package/src/server/create.ts

@@ -1276,6 +1276,117 @@ class LensServerImpl<
 			});
 		}
 
+		// SSE: GET /__lens/sse?path={path}&input={...}
+		// Dedicated endpoint with path in query param - consistent with POST body format
+		// This avoids base path parsing issues when server is mounted at /api etc.
+		if (request.method === "GET" && pathname.endsWith("/__lens/sse")) {
+			const path = url.searchParams.get("path");
+
+			// Validate path parameter
+			if (!path) {
+				const encoder = new TextEncoder();
+				const errorStream = new ReadableStream({
+					start(controller) {
+						const data = `event: error\ndata: ${JSON.stringify({ error: "Missing path parameter" })}\n\n`;
+						controller.enqueue(encoder.encode(data));
+						controller.close();
+					},
+				});
+				return new Response(errorStream, {
+					headers: {
+						"Content-Type": "text/event-stream",
+						"Cache-Control": "no-cache",
+						Connection: "keep-alive",
+					},
+				});
+			}
+
+			// Parse input from query params
+			const inputParam = url.searchParams.get("input");
+			let input: unknown;
+			if (inputParam) {
+				try {
+					input = JSON.parse(inputParam);
+				} catch {
+					// Return SSE error for malformed JSON
+					const encoder = new TextEncoder();
+					const errorStream = new ReadableStream({
+						start(controller) {
+							const data = `event: error\ndata: ${JSON.stringify({ error: "Invalid input JSON" })}\n\n`;
+							controller.enqueue(encoder.encode(data));
+							controller.close();
+						},
+					});
+					return new Response(errorStream, {
+						headers: {
+							"Content-Type": "text/event-stream",
+							"Cache-Control": "no-cache",
+							Connection: "keep-alive",
+						},
+					});
+				}
+			}
+
+			// Create SSE stream
+			const self = this;
+			const stream = new ReadableStream({
+				start(controller) {
+					const encoder = new TextEncoder();
+
+					try {
+						const result = self.execute({ path, input });
+
+						if (result && typeof result === "object" && "subscribe" in result) {
+							const observable = result as {
+								subscribe: (handlers: {
+									next: (value: unknown) => void;
+									error: (err: Error) => void;
+									complete: () => void;
+								}) => { unsubscribe: () => void };
+							};
+
+							const subscription = observable.subscribe({
+								next: (value) => {
+									// Send full LensResult envelope
+									const data = `data: ${JSON.stringify(value)}\n\n`;
+									controller.enqueue(encoder.encode(data));
+								},
+								error: (err) => {
+									const data = `event: error\ndata: ${JSON.stringify({ error: err.message })}\n\n`;
+									controller.enqueue(encoder.encode(data));
+									controller.close();
+								},
+								complete: () => {
+									controller.close();
+								},
+							});
+
+							// Clean up on abort
+							if (request.signal) {
+								request.signal.addEventListener("abort", () => {
+									subscription.unsubscribe();
+									controller.close();
+								});
+							}
+						}
+					} catch (execError) {
+						const errMsg = execError instanceof Error ? execError.message : "Internal error";
+						const data = `event: error\ndata: ${JSON.stringify({ error: errMsg })}\n\n`;
+						controller.enqueue(encoder.encode(data));
+						controller.close();
+					}
+				},
+			});
+
+			return new Response(stream, {
+				headers: {
+					"Content-Type": "text/event-stream",
+					"Cache-Control": "no-cache",
+					Connection: "keep-alive",
+				},
+			});
+		}
+
 		// Operations: POST to any path (client sends path in body)
 		if (request.method === "POST") {
 			let body: { path?: string; input?: unknown };