@slock-ai/daemon 0.48.0 → 0.49.0

package/dist/{chunk-B7XIMLOT.js → chunk-KNMCE6WB.js}

@@ -41,75 +41,6 @@ var logger = {
   }
 };
 
-// src/proxy.ts
-import { HttpsProxyAgent } from "https-proxy-agent";
-import { ProxyAgent } from "undici";
-var fetchDispatcherCache = /* @__PURE__ */ new Map();
-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 getProxyUrlForTarget(targetUrl, env) {
-  const protocol = new URL(targetUrl).protocol;
-  switch (protocol) {
-    case "wss:":
-      return env.WSS_PROXY || env.wss_proxy || env.HTTPS_PROXY || env.https_proxy || env.ALL_PROXY || env.all_proxy;
-    case "ws:":
-      return env.WS_PROXY || env.ws_proxy || env.HTTP_PROXY || env.http_proxy || env.ALL_PROXY || env.all_proxy;
-    case "https:":
-      return env.HTTPS_PROXY || env.https_proxy || env.ALL_PROXY || env.all_proxy;
-    case "http:":
-      return env.HTTP_PROXY || env.http_proxy || env.ALL_PROXY || env.all_proxy;
-    default:
-      return env.ALL_PROXY || env.all_proxy;
-  }
-}
-function shouldBypassProxy(targetUrl, env) {
-  const rawNoProxy = env.NO_PROXY || env.no_proxy;
-  if (!rawNoProxy) return false;
-  const url = new URL(targetUrl);
-  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 = getProxyUrlForTarget(wsUrl, env);
-  if (!proxyUrl) return void 0;
-  if (shouldBypassProxy(wsUrl, env)) return void 0;
-  return {
-    agent: new HttpsProxyAgent(proxyUrl)
-  };
-}
-function buildFetchDispatcher(targetUrl, env) {
-  const proxyUrl = getProxyUrlForTarget(targetUrl, env);
-  if (!proxyUrl) return void 0;
-  if (shouldBypassProxy(targetUrl, env)) return void 0;
-  const cached = fetchDispatcherCache.get(proxyUrl);
-  if (cached) return cached;
-  const dispatcher = new ProxyAgent(proxyUrl);
-  fetchDispatcherCache.set(proxyUrl, dispatcher);
-  return dispatcher;
-}
-
 // src/chatBridgeRequest.ts
 var DEFAULT_CHAT_BRIDGE_TOOL_TIMEOUT_MS = Number.parseInt(
   process.env.SLOCK_CHAT_BRIDGE_TOOL_TIMEOUT_MS || "",
@@ -207,55 +138,81 @@ async function executeResponseRequest(url, init, {
   }
 }
 
-// src/slockHome.ts
-import os from "os";
-import path from "path";
-import { existsSync } from "fs";
-var SLOCK_HOME_ENV = "SLOCK_HOME";
-function resolveDefaultSlockHome(homeDir = os.homedir()) {
-  return path.resolve(path.join(homeDir, ".slock"));
+// src/proxy.ts
+import { HttpsProxyAgent } from "https-proxy-agent";
+import { ProxyAgent } from "undici";
+var fetchDispatcherCache = /* @__PURE__ */ new Map();
+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 getProxyUrlForTarget(targetUrl, env) {
+  const protocol = new URL(targetUrl).protocol;
+  switch (protocol) {
+    case "wss:":
+      return env.WSS_PROXY || env.wss_proxy || env.HTTPS_PROXY || env.https_proxy || env.ALL_PROXY || env.all_proxy;
+    case "ws:":
+      return env.WS_PROXY || env.ws_proxy || env.HTTP_PROXY || env.http_proxy || env.ALL_PROXY || env.all_proxy;
+    case "https:":
+      return env.HTTPS_PROXY || env.https_proxy || env.ALL_PROXY || env.all_proxy;
+    case "http:":
+      return env.HTTP_PROXY || env.http_proxy || env.ALL_PROXY || env.all_proxy;
+    default:
+      return env.ALL_PROXY || env.all_proxy;
+  }
 }
-function resolveSlockHome(env = process.env, homeDir = os.homedir()) {
-  const raw = env[SLOCK_HOME_ENV]?.trim();
-  const root = raw && raw.length > 0 ? raw : resolveDefaultSlockHome(homeDir);
-  return path.resolve(root);
+function shouldBypassProxy(targetUrl, env) {
+  const rawNoProxy = env.NO_PROXY || env.no_proxy;
+  if (!rawNoProxy) return false;
+  const url = new URL(targetUrl);
+  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 resolveSlockHomePath(childPath, slockHome = resolveSlockHome()) {
-  return path.join(slockHome, childPath);
+function buildWebSocketOptions(wsUrl, env) {
+  const proxyUrl = getProxyUrlForTarget(wsUrl, env);
+  if (!proxyUrl) return void 0;
+  if (shouldBypassProxy(wsUrl, env)) return void 0;
+  return {
+    agent: new HttpsProxyAgent(proxyUrl)
+  };
 }
-function listLegacySlockStatePaths(slockHome = resolveSlockHome(), homeDir = os.homedir()) {
-  const defaultHome = resolveDefaultSlockHome(homeDir);
-  if (path.resolve(slockHome) === defaultHome) return [];
-  const candidates = [
-    {
-      path: path.join(defaultHome, "agents"),
-      destination: path.join(slockHome, "agents"),
-      description: "agent workspaces and per-agent runtime wrapper state"
-    },
-    {
-      path: path.join(defaultHome, "machines"),
-      destination: path.join(slockHome, "machines"),
-      description: "daemon machine locks, local traces, and machine-scoped state"
-    },
-    {
-      path: path.join(defaultHome, "attachments"),
-      destination: path.join(slockHome, "attachments"),
-      description: "chat bridge attachment download cache"
-    }
-  ];
-  return candidates.filter((candidate) => existsSync(candidate.path));
+function buildFetchDispatcher(targetUrl, env) {
+  const proxyUrl = getProxyUrlForTarget(targetUrl, env);
+  if (!proxyUrl) return void 0;
+  if (shouldBypassProxy(targetUrl, env)) return void 0;
+  const cached = fetchDispatcherCache.get(proxyUrl);
+  if (cached) return cached;
+  const dispatcher = new ProxyAgent(proxyUrl);
+  fetchDispatcherCache.set(proxyUrl, dispatcher);
+  return dispatcher;
 }
 
 export {
   subscribeDaemonLogs,
   logger,
-  buildWebSocketOptions,
-  buildFetchDispatcher,
   DEFAULT_CHAT_BRIDGE_TOOL_TIMEOUT_MS,
   executeJsonRequest,
   executeResponseRequest,
-  SLOCK_HOME_ENV,
-  resolveSlockHome,
-  resolveSlockHomePath,
-  listLegacySlockStatePaths
+  buildWebSocketOptions,
+  buildFetchDispatcher
 };