@melaya/runner 1.0.17 → 1.0.18

package/dist/connection.js

@@ -197,6 +197,102 @@ export async function connect(opts) {
             console.log(chalk.yellow(`  ■ Killed run ${data.runId.slice(0, 10)}...`));
         }
     });
+    // ── LLM stream relay ───────────────────────────────────────────────
+    //
+    // The cloud server picked the user's local Ollama / LM Studio model
+    // for an AI feature (Build-with-AI architect, etc.) — but the LLM
+    // server only exists on this machine, so we proxy the chat-completion
+    // here: fetch the local URL, stream chunks back over the existing
+    // socket. The server-side `streamLLMViaRunner()` consumes them.
+    //
+    // Protocol:
+    //   server → runner: runner:llm-stream-request { reqId, url, headers, body }
+    //   runner → server: runner:llm-stream-chunk   { reqId, chunk: string }
+    //   runner → server: runner:llm-stream-end     { reqId, status }
+    //   runner → server: runner:llm-stream-error   { reqId, error }
+    //   server → runner: runner:llm-stream-cancel  { reqId }
+    const _activeLLMStreams = new Map();
+    socket.on("runner:llm-stream-request", async (req) => {
+        const reqId = req?.reqId;
+        if (!reqId || typeof req.url !== "string")
+            return;
+        // Defense-in-depth: only allow loopback URLs. The server already
+        // generates these as `http://localhost:1234` / `http://localhost:11434`,
+        // but enforcing it here means a compromised server connection can't
+        // pivot the runner into making outbound requests on its behalf.
+        let parsed;
+        try {
+            parsed = new URL(req.url);
+        }
+        catch {
+            socket.emit("runner:llm-stream-error", { reqId, error: "invalid_url" });
+            return;
+        }
+        if (parsed.hostname !== "localhost" && parsed.hostname !== "127.0.0.1" && parsed.hostname !== "::1") {
+            socket.emit("runner:llm-stream-error", { reqId, error: "non_loopback_url_rejected" });
+            return;
+        }
+        if (opts.verbose)
+            console.log(chalk.gray(`  [llm-relay] ${reqId.slice(0, 12)} → ${req.url}`));
+        const ac = new AbortController();
+        _activeLLMStreams.set(reqId, ac);
+        try {
+            const upstream = await fetch(req.url, {
+                method: "POST",
+                headers: req.headers || { "content-type": "application/json" },
+                body: req.body || "",
+                signal: ac.signal,
+            });
+            if (!upstream.body) {
+                const text = await upstream.text().catch(() => "");
+                socket.emit("runner:llm-stream-error", {
+                    reqId,
+                    error: `upstream_no_body status=${upstream.status} ${text.slice(0, 200)}`,
+                });
+                return;
+            }
+            // Pipe chunks back as decoded text. The cloud server's parser is
+            // text-oriented (SSE `data:` lines) so we decode here and ship
+            // strings rather than base64 — keeps the WS payload small + lets
+            // the server keep its existing line-buffer code path.
+            const reader = upstream.body.getReader();
+            const decoder = new TextDecoder();
+            while (true) {
+                const { value, done } = await reader.read();
+                if (done)
+                    break;
+                const chunk = decoder.decode(value, { stream: true });
+                if (chunk.length > 0) {
+                    socket.emit("runner:llm-stream-chunk", { reqId, chunk });
+                }
+            }
+            // Flush any tail bytes.
+            const tail = decoder.decode();
+            if (tail.length > 0)
+                socket.emit("runner:llm-stream-chunk", { reqId, chunk: tail });
+            socket.emit("runner:llm-stream-end", { reqId, status: upstream.status });
+            if (opts.verbose)
+                console.log(chalk.gray(`  [llm-relay] ${reqId.slice(0, 12)} ◄ end ${upstream.status}`));
+        }
+        catch (e) {
+            if (e?.name === "AbortError") {
+                socket.emit("runner:llm-stream-error", { reqId, error: "aborted" });
+            }
+            else {
+                socket.emit("runner:llm-stream-error", { reqId, error: String(e?.message || e) });
+            }
+        }
+        finally {
+            _activeLLMStreams.delete(reqId);
+        }
+    });
+    socket.on("runner:llm-stream-cancel", (req) => {
+        const ac = _activeLLMStreams.get(req?.reqId);
+        if (ac) {
+            ac.abort();
+            _activeLLMStreams.delete(req.reqId);
+        }
+    });
     // ── Graceful shutdown ──────────────────────────────────────────────
     const cleanup = () => {
         console.log(chalk.gray("\n  Shutting down..."));

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@melaya/runner",
-  "version": "1.0.17",
+  "version": "1.0.18",
   "description": "Run Melaya AI pipelines locally with your own LM Studio or Ollama models",
   "license": "UNLICENSED",
   "private": false,