@slock-ai/daemon 0.31.3-alpha.8 → 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;
@@ -2178,16 +2229,22 @@ function summarizeIncomingMessage(msg) {
   }
 }
 function detectRuntimes() {
-  const detected = [];
+  const ids = [];
+  const versions = {};
   const cmd = process.platform === "win32" ? "where" : "which";
   for (const rt of RUNTIMES) {
     try {
       execSync2(`${cmd} ${rt.binary}`, { stdio: "pipe" });
-      detected.push(rt.id);
+      ids.push(rt.id);
+      try {
+        const ver = execSync2(`${rt.binary} --version`, { stdio: "pipe", timeout: 5e3 }).toString().trim().split("\n")[0];
+        versions[rt.id] = ver;
+      } catch {
+      }
     } catch {
     }
   }
-  return detected;
+  return { ids, versions };
 }
 var args = process.argv.slice(2);
 var serverUrl = "";
@@ -2290,8 +2347,9 @@ connection = new DaemonConnection({
     }
   },
   onConnect: () => {
-    const runtimes = detectRuntimes();
-    logger.info(`[Daemon] Detected runtimes: ${runtimes.join(", ") || "none"}`);
+    const { ids: runtimes, versions: runtimeVersions } = detectRuntimes();
+    const runtimeInfo = runtimes.map((id) => runtimeVersions[id] ? `${id} (${runtimeVersions[id]})` : id);
+    logger.info(`[Daemon] Detected runtimes: ${runtimeInfo.join(", ") || "none"}`);
     connection.send({
       type: "ready",
       capabilities: ["agent:start", "agent:stop", "agent:deliver", "workspace:files"],

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@slock-ai/daemon",
-  "version": "0.31.3-alpha.8",
+  "version": "0.32.1",
   "type": "module",
   "bin": {
     "slock-daemon": "dist/index.js"
@@ -16,28 +16,28 @@
   "publishConfig": {
     "access": "public"
   },
+  "dependencies": {
+    "@modelcontextprotocol/sdk": "^1.29.0",
+    "https-proxy-agent": "^7.0.6",
+    "ws": "^8.20.0",
+    "zod": "^4.3.6"
+  },
+  "devDependencies": {
+    "@types/node": "^25.5.0",
+    "@types/ws": "^8.18.1",
+    "tsup": "^8.5.1",
+    "typescript": "^5.9.3",
+    "@slock-ai/shared": "0.1.0"
+  },
   "scripts": {
     "dev": "tsx watch src/index.ts",
     "start": "tsx src/index.ts",
     "build": "tsup",
     "test": "node --import tsx --test --test-force-exit 'src/**/*.test.ts'",
-    "prepublishOnly": "pnpm run build",
     "typecheck": "tsc --noEmit",
     "release:patch": "npm version patch --no-git-tag-version && cd ../.. && pnpm install --lockfile-only && git add packages/daemon/package.json pnpm-lock.yaml && git commit -m \"chore: bump @slock-ai/daemon to v$(node -p \"require('./packages/daemon/package.json').version\")\" && git tag daemon-v$(node -p \"require('./packages/daemon/package.json').version\") && git push && git push --tags",
     "release:minor": "npm version minor --no-git-tag-version && cd ../.. && pnpm install --lockfile-only && git add packages/daemon/package.json pnpm-lock.yaml && git commit -m \"chore: bump @slock-ai/daemon to v$(node -p \"require('./packages/daemon/package.json').version\")\" && git tag daemon-v$(node -p \"require('./packages/daemon/package.json').version\") && git push && git push --tags",
     "release:major": "npm version major --no-git-tag-version && cd ../.. && pnpm install --lockfile-only && git add packages/daemon/package.json pnpm-lock.yaml && git commit -m \"chore: bump @slock-ai/daemon to v$(node -p \"require('./packages/daemon/package.json').version\")\" && git tag daemon-v$(node -p \"require('./packages/daemon/package.json').version\") && git push && git push --tags",
     "release:alpha": "npm version prerelease --preid=alpha --no-git-tag-version && cd ../.. && pnpm install --lockfile-only && git add packages/daemon/package.json pnpm-lock.yaml && git commit -m \"chore: bump @slock-ai/daemon to v$(node -p \"require('./packages/daemon/package.json').version\")\" && git tag daemon-v$(node -p \"require('./packages/daemon/package.json').version\") && git push && git push --tags"
-  },
-  "dependencies": {
-    "@modelcontextprotocol/sdk": "^1.29.0",
-    "ws": "^8.20.0",
-    "zod": "^4.3.6"
-  },
-  "devDependencies": {
-    "@slock-ai/shared": "workspace:*",
-    "@types/node": "^25.5.0",
-    "@types/ws": "^8.18.1",
-    "tsup": "^8.5.1",
-    "typescript": "^5.9.3"
   }
-}
+}