@slock-ai/daemon 0.55.0 → 0.55.1-play.20260530150714

package/dist/chat-bridge.js

@@ -2,7 +2,7 @@
 import {
   daemonFetch,
   executeJsonRequest
-} from "./chunk-VOZJ2ELH.js";
+} from "./chunk-M2KQBJR3.js";
 
 // src/chat-bridge.ts
 import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";

package/dist/{chunk-VOZJ2ELH.js → chunk-M2KQBJR3.js}

@@ -142,6 +142,10 @@ async function executeResponseRequest(url, init, {
 import { HttpsProxyAgent } from "https-proxy-agent";
 import { ProxyAgent } from "undici";
 var fetchDispatcherCache = /* @__PURE__ */ new Map();
+function getFetchPreResponseTimeoutMs(env) {
+  const parsed = Number.parseInt(env.SLOCK_DAEMON_FETCH_PRE_RESPONSE_TIMEOUT_MS || "", 10);
+  return Number.isFinite(parsed) && parsed > 0 ? parsed : 3e4;
+}
 function getDefaultPort(protocol) {
   switch (protocol) {
     case "https:":
@@ -196,24 +200,53 @@ function buildWebSocketOptions(wsUrl, env) {
     agent: new HttpsProxyAgent(proxyUrl)
   };
 }
-function buildFetchDispatcher(targetUrl, env) {
+function resolveProxyUrl(targetUrl, env) {
   const proxyUrl = getProxyUrlForTarget(targetUrl, env);
   if (!proxyUrl) return void 0;
   if (shouldBypassProxy(targetUrl, env)) return void 0;
+  return proxyUrl;
+}
+function buildFetchDispatcher(targetUrl, env) {
+  const proxyUrl = resolveProxyUrl(targetUrl, env);
+  if (!proxyUrl) return void 0;
   const cached = fetchDispatcherCache.get(proxyUrl);
   if (cached) return cached;
-  const dispatcher = new ProxyAgent(proxyUrl);
+  const timeoutMs = getFetchPreResponseTimeoutMs(env);
+  const dispatcher = new ProxyAgent({
+    uri: proxyUrl,
+    // All three are pre-response and body-agnostic (see getFetchPreResponseTimeoutMs):
+    // headersTimeout = headers-hang leg; requestTls.timeout = CONNECT-tunnel
+    // establish leg; connect.timeout = socket to the proxy itself (defensive).
+    connect: { timeout: timeoutMs },
+    requestTls: { timeout: timeoutMs },
+    headersTimeout: timeoutMs
+  });
   fetchDispatcherCache.set(proxyUrl, dispatcher);
   return dispatcher;
 }
+function evictFetchDispatcher(targetUrl, env) {
+  const proxyUrl = resolveProxyUrl(targetUrl, env);
+  if (!proxyUrl) return false;
+  const cached = fetchDispatcherCache.get(proxyUrl);
+  if (!cached) return false;
+  fetchDispatcherCache.delete(proxyUrl);
+  void Promise.resolve().then(() => cached.close()).catch(() => cached.destroy?.(new Error("evicted"))).catch(() => {
+  });
+  return true;
+}
 
 // src/daemonFetch.ts
 function withDaemonFetchProxy(input, init = {}, env = process.env) {
   const dispatcher = buildFetchDispatcher(input.toString(), env);
   return dispatcher ? { ...init, dispatcher } : init;
 }
-function daemonFetch(input, init, env = process.env) {
-  return fetch(input, withDaemonFetchProxy(input, init, env));
+async function daemonFetch(input, init, env = process.env) {
+  try {
+    return await fetch(input, withDaemonFetchProxy(input, init, env));
+  } catch (err) {
+    evictFetchDispatcher(input.toString(), env);
+    throw err;
+  }
 }
 
 export {