@slock-ai/daemon 0.32.0 → 0.32.1

package/dist/index.js

@@ -10,6 +10,7 @@ import { fileURLToPath } from "url";
 
 // src/connection.ts
 import WebSocket from "ws";
+import { HttpsProxyAgent } from "https-proxy-agent";
 
 // src/logger.ts
 function timestamp() {
@@ -43,6 +44,52 @@ var systemClock = {
   clearTimeout: (timer) => clearTimeout(timer)
 };
 var INBOUND_WATCHDOG_MS = 7e4;
+function getProxyUrlForWebSocket(wsUrl, env) {
+  const protocol = new URL(wsUrl).protocol;
+  if (protocol === "wss:") {
+    return env.WSS_PROXY || env.wss_proxy || env.HTTPS_PROXY || env.https_proxy || env.ALL_PROXY || env.all_proxy;
+  }
+  return env.WS_PROXY || env.ws_proxy || env.HTTP_PROXY || env.http_proxy || env.ALL_PROXY || env.all_proxy;
+}
+function getDefaultPort(protocol) {
+  switch (protocol) {
+    case "https:":
+    case "wss:":
+      return "443";
+    case "http:":
+    case "ws:":
+      return "80";
+    default:
+      return "";
+  }
+}
+function hostMatchesNoProxyEntry(hostname, ruleHost) {
+  if (!ruleHost) return false;
+  const normalizedRule = ruleHost.replace(/^\*\./, ".").replace(/^\./, "").toLowerCase();
+  const normalizedHost = hostname.toLowerCase();
+  return normalizedHost === normalizedRule || normalizedHost.endsWith(`.${normalizedRule}`);
+}
+function shouldBypassProxy(wsUrl, env) {
+  const rawNoProxy = env.NO_PROXY || env.no_proxy;
+  if (!rawNoProxy) return false;
+  const url = new URL(wsUrl);
+  const hostname = url.hostname.toLowerCase();
+  const port = url.port || getDefaultPort(url.protocol);
+  return rawNoProxy.split(",").map((entry) => entry.trim()).filter(Boolean).some((entry) => {
+    if (entry === "*") return true;
+    const [ruleHost, rulePort] = entry.split(":", 2);
+    if (rulePort && rulePort !== port) return false;
+    return hostMatchesNoProxyEntry(hostname, ruleHost);
+  });
+}
+function buildWebSocketOptions(wsUrl, env) {
+  const proxyUrl = getProxyUrlForWebSocket(wsUrl, env);
+  if (!proxyUrl) return void 0;
+  if (shouldBypassProxy(wsUrl, env)) return void 0;
+  return {
+    agent: new HttpsProxyAgent(proxyUrl)
+  };
+}
 var DaemonConnection = class {
   ws = null;
   options;
@@ -96,8 +143,12 @@ var DaemonConnection = class {
     if (!this.shouldConnect) return;
     if (this.ws && this.ws.readyState !== WebSocket.CLOSED) return;
     const wsUrl = this.options.serverUrl.replace(/^http/, "ws") + `/daemon/connect?key=${this.options.apiKey}`;
+    const wsOptions = buildWebSocketOptions(wsUrl, this.options.proxyEnv ?? process.env);
     logger.info(`[Daemon] Connecting to ${this.options.serverUrl}...`);
-    const ws = this.options.wsFactory ? this.options.wsFactory(wsUrl) : new WebSocket(wsUrl);
+    if (wsOptions?.agent) {
+      logger.info("[Daemon] Using configured proxy for WebSocket connection");
+    }
+    const ws = this.options.wsFactory ? this.options.wsFactory(wsUrl, wsOptions) : new WebSocket(wsUrl, wsOptions);
     this.ws = ws;
     ws.on("open", () => {
       if (this.ws !== ws) return;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@slock-ai/daemon",
-  "version": "0.32.0",
+  "version": "0.32.1",
   "type": "module",
   "bin": {
     "slock-daemon": "dist/index.js"
@@ -18,6 +18,7 @@
   },
   "dependencies": {
     "@modelcontextprotocol/sdk": "^1.29.0",
+    "https-proxy-agent": "^7.0.6",
     "ws": "^8.20.0",
     "zod": "^4.3.6"
   },