@agentconnect.md/daemon 1.0.0-rc.216 → 1.0.0-rc.217

package/dist/{run-foreground-BroK115h.js → run-foreground-CK2rQc1c.js}

@@ -3,11 +3,16 @@ import { n as require_ms, t as require_src$2 } from "./src-DDtlVutj.js";
 import { t as DAEMON_VERSION } from "./version-DGaRXjBK.js";
 import { a as agentChildEnv, i as selectAgent, n as findAgentFiles, o as loadConfig, r as loadAgents, s as persistDaemonId } from "./load-agents-nWFFmN5-.js";
 import { l as resolveRoot, o as mcpSocketPath, u as statePath } from "./paths-DEcUO8lC.js";
-import { _ as resolveRuntimes, a as initGitInjection, c as simpleGit, d as MAX_FRAME_BYTES, f as buildEnvelope, g as cachedRuntimeVersions, h as cachedRuntimeNames, i as prepareWorkspace, m as encode, n as installedRuntimes, o as probeGitVersion, p as decodeEnvelope, r as prefetchWorkspace, s as sessionGitEnv, t as AcpHost, u as normalizeGitUrl } from "./acp-host-D4Gc3jWq.js";
+import { _ as resolveRuntimes, a as initGitInjection, c as simpleGit, d as MAX_FRAME_BYTES, f as buildEnvelope, g as cachedRuntimeVersions, h as cachedRuntimeNames, i as prepareWorkspace, m as encode, n as installedRuntimes, o as probeGitVersion, p as decodeEnvelope, r as prefetchWorkspace, s as sessionGitEnv, t as AcpHost, u as normalizeGitUrl } from "./acp-host-CeJJZbtg.js";
 import { i as GitCredentialCache, n as gitcredSocketPath, r as writeGitcredShim, t as GitCredServer } from "./gitcred-server-Dcsq6QJe.js";
 import { n as encodeFrame, t as decodeFrames } from "./ipc-2Xbxe7uu.js";
+import { URL as URL$1 } from "url";
+import * as tls from "tls";
+import * as net$2 from "net";
 import * as sp from "node:path";
 import { dirname, join, relative, resolve, sep } from "node:path";
+import * as http$6 from "http";
+import { Agent } from "https";
 import { chmodSync, existsSync, mkdirSync, mkdtempSync, promises, readFileSync, rmSync, stat, unwatchFile, watch, watchFile, writeFileSync } from "node:fs";
 import { EventEmitter } from "node:events";
 import { hostname, tmpdir, type } from "node:os";
@@ -16,6 +21,7 @@ import { Readable } from "node:stream";
 import net from "node:net";
 import { lstat, open, readdir, realpath, stat as stat$1 } from "node:fs/promises";
 import { DatabaseSync } from "node:sqlite";
+import assert from "assert";
 //#region ../../node_modules/.pnpm/ws@8.21.0/node_modules/ws/lib/constants.js
 var require_constants$1 = /* @__PURE__ */ __commonJSMin(((exports, module) => {
 	const BINARY_TYPES = [
@@ -2059,12 +2065,12 @@ var require_extension = /* @__PURE__ */ __commonJSMin(((exports, module) => {
 var require_websocket = /* @__PURE__ */ __commonJSMin(((exports, module) => {
 	const EventEmitter$3 = __require("events");
 	const https$3 = __require("https");
-	const http$7 = __require("http");
-	const net$2 = __require("net");
-	const tls = __require("tls");
+	const http$8 = __require("http");
+	const net$3 = __require("net");
+	const tls$1 = __require("tls");
 	const { randomBytes: randomBytes$1, createHash: createHash$1 } = __require("crypto");
 	const { Duplex: Duplex$2, Readable: Readable$1 } = __require("stream");
-	const { URL: URL$1 } = __require("url");
+	const { URL: URL$2 } = __require("url");
 	const PerMessageDeflate = require_permessage_deflate();
 	const Receiver = require_receiver$1();
 	const Sender = require_sender();
@@ -2605,9 +2611,9 @@ var require_websocket = /* @__PURE__ */ __commonJSMin(((exports, module) => {
 		websocket._closeTimeout = opts.closeTimeout;
 		if (!protocolVersions.includes(opts.protocolVersion)) throw new RangeError(`Unsupported protocol version: ${opts.protocolVersion} (supported versions: ${protocolVersions.join(", ")})`);
 		let parsedUrl;
-		if (address instanceof URL$1) parsedUrl = address;
+		if (address instanceof URL$2) parsedUrl = address;
 		else try {
-			parsedUrl = new URL$1(address);
+			parsedUrl = new URL$2(address);
 		} catch {
 			throw new SyntaxError(`Invalid URL: ${address}`);
 		}
@@ -2630,7 +2636,7 @@ var require_websocket = /* @__PURE__ */ __commonJSMin(((exports, module) => {
 		}
 		const defaultPort = isSecure ? 443 : 80;
 		const key = randomBytes$1(16).toString("base64");
-		const request = isSecure ? https$3.request : http$7.request;
+		const request = isSecure ? https$3.request : http$8.request;
 		const protocolSet = /* @__PURE__ */ new Set();
 		let perMessageDeflate;
 		opts.createConnection = opts.createConnection || (isSecure ? tlsConnect : netConnect);
@@ -2713,7 +2719,7 @@ var require_websocket = /* @__PURE__ */ __commonJSMin(((exports, module) => {
 				req.abort();
 				let addr;
 				try {
-					addr = new URL$1(location, address);
+					addr = new URL$2(location, address);
 				} catch (e) {
 					emitErrorAndClose(websocket, /* @__PURE__ */ new SyntaxError(`Invalid URL: ${location}`));
 					return;
@@ -2806,7 +2812,7 @@ var require_websocket = /* @__PURE__ */ __commonJSMin(((exports, module) => {
 	*/
 	function netConnect(options) {
 		options.path = options.socketPath;
-		return net$2.connect(options);
+		return net$3.connect(options);
 	}
 	/**
 	* Create a `tls.TLSSocket` and initiate a connection.
@@ -2817,8 +2823,8 @@ var require_websocket = /* @__PURE__ */ __commonJSMin(((exports, module) => {
 	*/
 	function tlsConnect(options) {
 		options.path = void 0;
-		if (!options.servername && options.servername !== "") options.servername = net$2.isIP(options.host) ? "" : options.host;
-		return tls.connect(options);
+		if (!options.servername && options.servername !== "") options.servername = net$3.isIP(options.host) ? "" : options.host;
+		return tls$1.connect(options);
 	}
 	/**
 	* Abort the handshake and emit an error.
@@ -3202,7 +3208,7 @@ var require_subprotocol = /* @__PURE__ */ __commonJSMin(((exports, module) => {
 //#region ../../node_modules/.pnpm/ws@8.21.0/node_modules/ws/lib/websocket-server.js
 var require_websocket_server = /* @__PURE__ */ __commonJSMin(((exports, module) => {
 	const EventEmitter$2 = __require("events");
-	const http$6 = __require("http");
+	const http$7 = __require("http");
 	const { Duplex } = __require("stream");
 	const { createHash } = __require("crypto");
 	const extension = require_extension();
@@ -3283,8 +3289,8 @@ var require_websocket_server = /* @__PURE__ */ __commonJSMin(((exports, module)
 			};
 			if (options.port == null && !options.server && !options.noServer || options.port != null && (options.server || options.noServer) || options.server && options.noServer) throw new TypeError("One and only one of the \"port\", \"server\", or \"noServer\" options must be specified");
 			if (options.port != null) {
-				this._server = http$6.createServer((req, res) => {
-					const body = http$6.STATUS_CODES[426];
+				this._server = http$7.createServer((req, res) => {
+					const body = http$7.STATUS_CODES[426];
 					res.writeHead(426, {
 						"Content-Length": body.length,
 						"Content-Type": "text/plain"
@@ -3554,7 +3560,7 @@ var require_websocket_server = /* @__PURE__ */ __commonJSMin(((exports, module)
 	* @private
 	*/
 	function abortHandshake(socket, code, message, headers) {
-		message = message || http$6.STATUS_CODES[code];
+		message = message || http$7.STATUS_CODES[code];
 		headers = {
 			Connection: "close",
 			"Content-Type": "text/html",
@@ -3562,7 +3568,7 @@ var require_websocket_server = /* @__PURE__ */ __commonJSMin(((exports, module)
 			...headers
 		};
 		socket.once("finish", socket.destroy);
-		socket.end(`HTTP/1.1 ${code} ${http$6.STATUS_CODES[code]}\r\n` + Object.keys(headers).map((h) => `${h}: ${headers[h]}`).join("\r\n") + "\r\n\r\n" + message);
+		socket.end(`HTTP/1.1 ${code} ${http$7.STATUS_CODES[code]}\r\n` + Object.keys(headers).map((h) => `${h}: ${headers[h]}`).join("\r\n") + "\r\n\r\n" + message);
 	}
 	/**
 	* Emit a `'wsClientError'` event on a `WebSocketServer` if there is at least
@@ -3584,6 +3590,9 @@ var require_websocket_server = /* @__PURE__ */ __commonJSMin(((exports, module)
 		} else abortHandshake(socket, code, message, headers);
 	}
 }));
+//#endregion
+//#region ../../node_modules/.pnpm/ws@8.21.0/node_modules/ws/wrapper.mjs
+var import_src = /* @__PURE__ */ __toESM(require_src$2(), 1);
 require_stream();
 require_extension();
 require_permessage_deflate();
@@ -6607,6 +6616,342 @@ var CpRoutingLayer = class {
 	}
 };
 //#endregion
+//#region ../../node_modules/.pnpm/agent-base@9.0.0/node_modules/agent-base/dist/index.js
+const INTERNAL = Symbol("AgentBaseInternalState");
+var Agent$1 = class extends http$6.Agent {
+	constructor(opts) {
+		super(opts);
+		this[INTERNAL] = {};
+	}
+	/**
+	* Determine whether this is an `http` or `https` request.
+	*/
+	isSecureEndpoint(options) {
+		if (options) {
+			if (typeof options.secureEndpoint === "boolean") return options.secureEndpoint;
+			if (typeof options.protocol === "string") return options.protocol === "https:";
+		}
+		const { stack } = /* @__PURE__ */ new Error();
+		if (typeof stack !== "string") return false;
+		return stack.split("\n").some((l) => l.indexOf("(https.js:") !== -1 || l.indexOf("node:https:") !== -1);
+	}
+	incrementSockets(name) {
+		if (this.maxSockets === Infinity && this.maxTotalSockets === Infinity) return null;
+		if (!this.sockets[name]) this.sockets[name] = [];
+		const fakeSocket = new net$2.Socket({ writable: false });
+		this.sockets[name].push(fakeSocket);
+		this.totalSocketCount++;
+		return fakeSocket;
+	}
+	decrementSockets(name, socket) {
+		if (!this.sockets[name] || socket === null) return;
+		const sockets = this.sockets[name];
+		const index = sockets.indexOf(socket);
+		if (index !== -1) {
+			sockets.splice(index, 1);
+			this.totalSocketCount--;
+			if (sockets.length === 0) delete this.sockets[name];
+		}
+	}
+	getName(options) {
+		if (this.isSecureEndpoint(options)) return Agent.prototype.getName.call(this, options);
+		return super.getName(options);
+	}
+	createSocket(req, options, cb) {
+		const connectOpts = {
+			...options,
+			secureEndpoint: this.isSecureEndpoint(options)
+		};
+		const name = this.getName(connectOpts);
+		const fakeSocket = this.incrementSockets(name);
+		Promise.resolve().then(() => this.connect(req, connectOpts)).then((socket) => {
+			this.decrementSockets(name, fakeSocket);
+			if (typeof socket.addRequest === "function") try {
+				return socket.addRequest(req, connectOpts);
+			} catch (err) {
+				return cb(err);
+			}
+			this[INTERNAL].currentSocket = socket;
+			super.createSocket(req, options, cb);
+		}, (err) => {
+			this.decrementSockets(name, fakeSocket);
+			cb(err);
+		});
+	}
+	createConnection() {
+		const socket = this[INTERNAL].currentSocket;
+		this[INTERNAL].currentSocket = void 0;
+		if (!socket) throw new Error("No socket was returned in the `connect()` function");
+		return socket;
+	}
+	get defaultPort() {
+		return this[INTERNAL].defaultPort ?? (this.protocol === "https:" ? 443 : 80);
+	}
+	set defaultPort(v) {
+		if (this[INTERNAL]) this[INTERNAL].defaultPort = v;
+	}
+	get protocol() {
+		return this[INTERNAL].protocol ?? (this.isSecureEndpoint() ? "https:" : "http:");
+	}
+	set protocol(v) {
+		if (this[INTERNAL]) this[INTERNAL].protocol = v;
+	}
+};
+//#endregion
+//#region ../../node_modules/.pnpm/https-proxy-agent@9.1.0/node_modules/https-proxy-agent/dist/parse-proxy-response.js
+const debug$1 = (0, import_src.default)("https-proxy-agent:parse-proxy-response");
+function parseProxyResponse(socket) {
+	return new Promise((resolve, reject) => {
+		let buffersLength = 0;
+		const buffers = [];
+		function read() {
+			const b = socket.read();
+			if (b) ondata(b);
+			else socket.once("readable", read);
+		}
+		function cleanup() {
+			socket.removeListener("end", onend);
+			socket.removeListener("error", onerror);
+			socket.removeListener("readable", read);
+		}
+		function onend() {
+			cleanup();
+			debug$1("onend");
+			reject(/* @__PURE__ */ new Error("Proxy connection ended before receiving CONNECT response"));
+		}
+		function onerror(err) {
+			cleanup();
+			debug$1("onerror %o", err);
+			reject(err);
+		}
+		function ondata(b) {
+			buffers.push(b);
+			buffersLength += b.length;
+			const buffered = Buffer.concat(buffers, buffersLength);
+			const endOfHeaders = buffered.indexOf("\r\n\r\n");
+			if (endOfHeaders === -1) {
+				debug$1("have not received end of HTTP headers yet...");
+				read();
+				return;
+			}
+			const headerParts = buffered.slice(0, endOfHeaders).toString("ascii").split("\r\n");
+			const firstLine = headerParts.shift();
+			if (!firstLine) {
+				socket.destroy();
+				return reject(/* @__PURE__ */ new Error("No header received from proxy CONNECT response"));
+			}
+			const firstLineParts = firstLine.split(" ");
+			const statusCode = +firstLineParts[1];
+			const statusText = firstLineParts.slice(2).join(" ");
+			const headers = {};
+			for (const header of headerParts) {
+				if (!header) continue;
+				const firstColon = header.indexOf(":");
+				if (firstColon === -1) {
+					socket.destroy();
+					return reject(/* @__PURE__ */ new Error(`Invalid header from proxy CONNECT response: "${header}"`));
+				}
+				const key = header.slice(0, firstColon).toLowerCase();
+				const value = header.slice(firstColon + 1).trimStart();
+				const current = headers[key];
+				if (typeof current === "string") headers[key] = [current, value];
+				else if (Array.isArray(current)) current.push(value);
+				else headers[key] = value;
+			}
+			debug$1("got proxy server response: %o %o", firstLine, headers);
+			cleanup();
+			resolve({
+				connect: {
+					statusCode,
+					statusText,
+					headers
+				},
+				buffered
+			});
+		}
+		socket.on("error", onerror);
+		socket.on("end", onend);
+		read();
+	});
+}
+//#endregion
+//#region ../../node_modules/.pnpm/proxy-agent-negotiate@1.1.0/node_modules/proxy-agent-negotiate/dist/index.js
+function createNegotiateAuth() {
+	return async ({ response, scheme }) => {
+		if (scheme.toLowerCase() !== "negotiate") throw new Error(`Expected Negotiate scheme but got "${scheme}"`);
+		let kerberos;
+		try {
+			kerberos = await import("kerberos");
+		} catch {
+			throw new Error("The \"kerberos\" package is required for Negotiate proxy authentication. Install it with: npm install kerberos");
+		}
+		const proxyAuthenticate = response.headers["proxy-authenticate"] || "";
+		const challengeHeader = Array.isArray(proxyAuthenticate) ? proxyAuthenticate[0] : proxyAuthenticate;
+		const serverToken = typeof challengeHeader === "string" && challengeHeader.includes(" ") ? challengeHeader.split(" ").slice(1).join(" ") : void 0;
+		const token = await (await kerberos.initializeClient("HTTP@proxy", { mechOID: kerberos.GSS_MECH_OID_SPNEGO })).step(serverToken || "");
+		if (!token) throw new Error("Kerberos client.step() returned no token");
+		return { headers: { "Proxy-Authorization": `Negotiate ${token}` } };
+	};
+}
+//#endregion
+//#region ../../node_modules/.pnpm/https-proxy-agent@9.1.0/node_modules/https-proxy-agent/dist/index.js
+const debug = (0, import_src.default)("https-proxy-agent");
+const setServernameFromNonIpHost = (options) => {
+	if (options.servername === void 0 && options.host && !net$2.isIP(options.host)) return {
+		...options,
+		servername: options.host
+	};
+	return options;
+};
+/**
+* The `HttpsProxyAgent` implements an HTTP Agent subclass that connects to
+* the specified "HTTP(s) proxy server" in order to proxy HTTPS requests.
+*
+* Outgoing HTTP requests are first tunneled through the proxy server using the
+* `CONNECT` HTTP request method to establish a connection to the proxy server,
+* and then the proxy server connects to the destination target and issues the
+* HTTP request from the proxy server.
+*
+* `https:` requests have their socket connection upgraded to TLS once
+* the connection to the proxy server has been established.
+*/
+var HttpsProxyAgent = class extends Agent$1 {
+	constructor(proxy, opts) {
+		super(opts);
+		this.options = { path: void 0 };
+		this.proxy = typeof proxy === "string" ? new URL$1(proxy) : proxy;
+		this.proxyHeaders = opts?.headers ?? {};
+		debug("Creating new HttpsProxyAgent instance: %o", this.proxy.href);
+		if (opts?.negotiate) this.onProxyAuth = createNegotiateAuth();
+		else if (opts?.onProxyAuth) this.onProxyAuth = opts.onProxyAuth;
+		const host = (this.proxy.hostname || this.proxy.host).replace(/^\[|\]$/g, "");
+		const port = this.proxy.port ? parseInt(this.proxy.port, 10) : this.proxy.protocol === "https:" ? 443 : 80;
+		this.connectOpts = {
+			ALPNProtocols: ["http/1.1"],
+			...opts ? omit(opts, "headers", "onProxyAuth", "negotiate") : null,
+			host,
+			port
+		};
+	}
+	/**
+	* Called when the node-core HTTP client library is creating a
+	* new HTTP request.
+	*/
+	async connect(req, opts) {
+		const { proxy } = this;
+		if (!opts.host) throw new TypeError("No \"host\" provided");
+		let socket;
+		if (proxy.protocol === "https:") {
+			debug("Creating `tls.Socket`: %o", this.connectOpts);
+			socket = tls.connect(setServernameFromNonIpHost(this.connectOpts));
+		} else {
+			debug("Creating `net.Socket`: %o", this.connectOpts);
+			socket = net$2.connect(this.connectOpts);
+		}
+		const headers = typeof this.proxyHeaders === "function" ? this.proxyHeaders() : { ...this.proxyHeaders };
+		const host = net$2.isIPv6(opts.host) ? `[${opts.host}]` : opts.host;
+		let payload = `CONNECT ${host}:${opts.port} HTTP/1.1\r\n`;
+		if (proxy.username || proxy.password) {
+			const auth = `${decodeURIComponent(proxy.username)}:${decodeURIComponent(proxy.password)}`;
+			headers["Proxy-Authorization"] = `Basic ${Buffer.from(auth).toString("base64")}`;
+		}
+		headers.Host = `${host}:${opts.port}`;
+		if (!headers["Proxy-Connection"]) headers["Proxy-Connection"] = this.keepAlive ? "Keep-Alive" : "close";
+		for (const name of Object.keys(headers)) payload += `${name}: ${headers[name]}\r\n`;
+		const proxyResponsePromise = parseProxyResponse(socket);
+		socket.write(`${payload}\r\n`);
+		const { connect, buffered } = await proxyResponsePromise;
+		req.emit("proxyConnect", connect);
+		this.emit("proxyConnect", connect, req);
+		req.emit("proxy", {
+			proxy: this.proxy.href,
+			socket
+		});
+		if (connect.statusCode === 200) {
+			req.once("socket", resume);
+			if (opts.secureEndpoint) {
+				debug("Upgrading socket connection to TLS");
+				return tls.connect({
+					...omit(setServernameFromNonIpHost(opts), "host", "path", "port"),
+					socket
+				});
+			}
+			return socket;
+		}
+		if (connect.statusCode === 407 && this.onProxyAuth) {
+			debug("Got 407 response, invoking onProxyAuth callback");
+			socket.destroy();
+			const proxyAuthenticate = connect.headers["proxy-authenticate"] || "";
+			const scheme = Array.isArray(proxyAuthenticate) ? proxyAuthenticate[0].split(/\s/)[0] : proxyAuthenticate.split(/\s/)[0];
+			const authResponse = await this.onProxyAuth({
+				response: connect,
+				scheme
+			});
+			return this._connectWithAuth(req, opts, authResponse.headers);
+		}
+		socket.destroy();
+		const fakeSocket = new net$2.Socket({ writable: false });
+		fakeSocket.readable = true;
+		req.once("socket", (s) => {
+			debug("Replaying proxy buffer for failed request");
+			assert(s.listenerCount("data") > 0);
+			s.push(buffered);
+			s.push(null);
+		});
+		return fakeSocket;
+	}
+	/**
+	* Retry a CONNECT request with additional auth headers.
+	*/
+	async _connectWithAuth(req, opts, authHeaders) {
+		const { proxy } = this;
+		let socket;
+		if (proxy.protocol === "https:") socket = tls.connect(setServernameFromNonIpHost(this.connectOpts));
+		else socket = net$2.connect(this.connectOpts);
+		const headers = typeof this.proxyHeaders === "function" ? this.proxyHeaders() : { ...this.proxyHeaders };
+		const host = net$2.isIPv6(opts.host) ? `[${opts.host}]` : opts.host;
+		let payload = `CONNECT ${host}:${opts.port} HTTP/1.1\r\n`;
+		if (proxy.username || proxy.password) {
+			const auth = `${decodeURIComponent(proxy.username)}:${decodeURIComponent(proxy.password)}`;
+			headers["Proxy-Authorization"] = `Basic ${Buffer.from(auth).toString("base64")}`;
+		}
+		Object.assign(headers, authHeaders);
+		headers.Host = `${host}:${opts.port}`;
+		if (!headers["Proxy-Connection"]) headers["Proxy-Connection"] = this.keepAlive ? "Keep-Alive" : "close";
+		for (const name of Object.keys(headers)) payload += `${name}: ${headers[name]}\r\n`;
+		const proxyResponsePromise = parseProxyResponse(socket);
+		socket.write(`${payload}\r\n`);
+		const { connect } = await proxyResponsePromise;
+		req.emit("proxyConnect", connect);
+		this.emit("proxyConnect", connect, req);
+		if (connect.statusCode === 200) {
+			req.once("socket", resume);
+			if (opts.secureEndpoint) {
+				debug("Upgrading socket connection to TLS");
+				return tls.connect({
+					...omit(setServernameFromNonIpHost(opts), "host", "path", "port"),
+					socket
+				});
+			}
+			return socket;
+		}
+		socket.destroy();
+		throw new Error(`Proxy authentication failed with status ${connect.statusCode} after retry`);
+	}
+};
+HttpsProxyAgent.protocols = ["http", "https"];
+function resume(socket) {
+	setImmediate(() => {
+		socket.resume();
+	});
+}
+function omit(obj, ...keys) {
+	const ret = {};
+	let key;
+	for (key in obj) if (!keys.includes(key)) ret[key] = obj[key];
+	return ret;
+}
+//#endregion
 //#region ../../node_modules/.pnpm/@slack+logger@4.0.1/node_modules/@slack/logger/dist/index.js
 var require_dist$8 = /* @__PURE__ */ __commonJSMin(((exports) => {
 	Object.defineProperty(exports, "__esModule", { value: true });
@@ -16172,7 +16517,7 @@ var require_follow_redirects = /* @__PURE__ */ __commonJSMin(((exports, module)
 	var http$4 = __require("http");
 	var https$1 = __require("https");
 	var Writable$1 = __require("stream").Writable;
-	var assert = __require("assert");
+	var assert$1 = __require("assert");
 	var debug = require_debug$1();
 	// istanbul ignore next
 	(function detectUnsupportedEnvironment() {
@@ -16183,7 +16528,7 @@ var require_follow_redirects = /* @__PURE__ */ __commonJSMin(((exports, module)
 	})();
 	var useNativeURL = false;
 	try {
-		assert(new URL(""));
+		assert$1(new URL(""));
 	} catch (error) {
 		useNativeURL = error.code === "ERR_INVALID_URL";
 	}
@@ -16492,7 +16837,7 @@ var require_follow_redirects = /* @__PURE__ */ __commonJSMin(((exports, module)
 				}, input, options);
 				options.nativeProtocols = nativeProtocols;
 				if (!isString(options.host) && !isString(options.hostname)) options.hostname = "::1";
-				assert.equal(options.protocol, protocol, "protocol mismatch");
+				assert$1.equal(options.protocol, protocol, "protocol mismatch");
 				debug("options", options);
 				return new RedirectableRequest(options, callback);
 			}
@@ -16581,7 +16926,7 @@ var require_follow_redirects = /* @__PURE__ */ __commonJSMin(((exports, module)
 		request.destroy(error);
 	}
 	function isSubdomain(subdomain, domain) {
-		assert(isString(subdomain) && isString(domain));
+		assert$1(isString(subdomain) && isString(domain));
 		var dot = subdomain.length - domain.length - 1;
 		return dot > 0 && subdomain[dot] === "." && subdomain.endsWith(domain);
 	}
@@ -63121,16 +63466,21 @@ var SlackConnection = class {
 	botToken;
 	botId = "";
 	workspaceUrl = "";
-	constructor(deps, factory = (o) => new App({
-		token: o.token,
-		appToken: o.appToken,
-		socketMode: true,
-		clientOptions: {
-			timeout: 1e4,
-			retryConfig: { retries: 2 }
-		},
-		...deps.boltDebug ? { logLevel: LogLevel.DEBUG } : {}
-	})) {
+	constructor(deps, factory = (o) => {
+		const proxyUrl = process.env.HTTPS_PROXY ?? process.env.HTTP_PROXY;
+		const agent = proxyUrl ? new HttpsProxyAgent(proxyUrl) : void 0;
+		return new App({
+			token: o.token,
+			appToken: o.appToken,
+			socketMode: true,
+			...agent ? { agent } : {},
+			clientOptions: {
+				timeout: 3e4,
+				retryConfig: { retries: 2 }
+			},
+			...deps.boltDebug ? { logLevel: LogLevel.DEBUG } : {}
+		});
+	}) {
 		this.deps = deps;
 		this.appToken = deps.group.appToken;
 		this.botToken = deps.group.botToken;
@@ -81825,6 +82175,7 @@ var Daemon = class Daemon {
 	hostStopping = /* @__PURE__ */ new Map();
 	idleSweepTimer;
 	cancelTimers = /* @__PURE__ */ new Map();
+	slackRetryTimers = /* @__PURE__ */ new Map();
 	constructor(opts = {}) {
 		this.opts = opts;
 		this.clock = opts.clock ?? systemClock;
@@ -81975,14 +82326,24 @@ var Daemon = class Daemon {
 				boltDebug: cfg.logging.level === "debug" || cfg.logging.level === "trace"
 			});
 			this.log.info(`slack: connecting (${group.integrations.length} integration(s): ${group.integrations.map((i) => i.agentId).join(", ")})…`);
-			await conn.start();
-			this.log.info(`slack: socket connected as bot user ${conn.botUserId}`);
-			for (const { integrationId } of group.integrations) {
-				this.botUserIds[integrationId] = conn.botUserId;
-				this.connByIntegration.set(integrationId, conn);
+			try {
+				await conn.start();
+				this.log.info(`slack: socket connected as bot user ${conn.botUserId}`);
+				for (const { integrationId } of group.integrations) {
+					this.botUserIds[integrationId] = conn.botUserId;
+					this.connByIntegration.set(integrationId, conn);
+				}
+				this.connections.push(conn);
+				this.refreshChannels(conn);
+			} catch (err) {
+				await conn.stop().catch(() => {});
+				this.log.warn(`slack: connection failed for appToken — retrying in 60s: ${formatErr(err)}`);
+				const timer = this.clock.setTimeout(() => {
+					if (this.draining) return;
+					this.retrySlackConnection(group).catch((e) => this.log.error(`slack: retry loop error: ${formatErr(e)}`));
+				}, 6e4);
+				this.slackRetryTimers.set(group.appToken, timer);
 			}
-			this.connections.push(conn);
-			this.refreshChannels(conn);
 		}
 		for (const a of agents) this.scheduler.sync(a.id, a.crons);
 		const cronCount = agents.reduce((n, a) => n + this.scheduler.count(a.id), 0);
@@ -82162,6 +82523,11 @@ var Daemon = class Daemon {
 				}
 				this.connections.push(conn);
 				this.refreshChannels(conn);
+				const pending = this.slackRetryTimers.get(group.appToken);
+				if (pending !== void 0) {
+					this.clock.clearTimeout(pending);
+					this.slackRetryTimers.delete(group.appToken);
+				}
 			} catch (err) {
 				this.log.error(`slack: failed to open runtime socket for appToken — leaving existing sockets intact: ${formatErr(err)}`);
 			}
@@ -82197,6 +82563,54 @@ var Daemon = class Daemon {
 			this.log.debug(`slack: channel snapshot refresh failed: ${formatErr(err)}`);
 		}
 	}
+	/**
+	* Background retry loop for a Slack connection that failed at initial startup.
+	* Creates a fresh SlackConnection (the old one is in an unknown state) and, on
+	* success, wires it into `botUserIds` / `connByIntegration` / `connections` so
+	* the agent can begin processing messages. On failure, schedules another retry
+	* at a slow, fixed interval — never gives up, so a temporary network outage
+	* self-heals without manual daemon restart.
+	*/
+	async retrySlackConnection(group) {
+		if (this.draining) return;
+		if ([...this.connByIntegration.values()].some((c) => c.appToken === group.appToken)) {
+			this.slackRetryTimers.delete(group.appToken);
+			return;
+		}
+		this.log.info(`slack: background retry for appToken (${group.integrations.length} integration(s): ${group.integrations.map((i) => i.agentId).join(", ")})…`);
+		const conn = new SlackConnection({
+			group,
+			newTraceId: () => randomUUID(),
+			onMessage: (msg) => {
+				this.nameResolver?.noteMessage(conn, msg);
+				this.onInbound(msg);
+			},
+			onChannelsChanged: () => void this.refreshChannels(conn),
+			onStatusAction: (a) => this.handleSlackStatusAction(a),
+			onStatusInfo: (key) => this.statusInfoForKey(key),
+			log: this.log,
+			boltDebug: this.cfg.logging.level === "debug" || this.cfg.logging.level === "trace"
+		});
+		try {
+			await conn.start();
+			this.log.info(`slack: background retry succeeded — connected as bot user ${conn.botUserId}`);
+			this.slackRetryTimers.delete(group.appToken);
+			for (const { integrationId } of group.integrations) {
+				this.botUserIds[integrationId] = conn.botUserId;
+				this.connByIntegration.set(integrationId, conn);
+			}
+			this.connections.push(conn);
+			this.refreshChannels(conn);
+		} catch (err) {
+			await conn.stop().catch(() => {});
+			this.log.warn(`slack: background retry failed — scheduling next attempt in 60s: ${formatErr(err)}`);
+			const timer = this.clock.setTimeout(() => {
+				if (this.draining) return;
+				this.retrySlackConnection(group).catch((e) => this.log.error(`slack: retry loop error: ${formatErr(e)}`));
+			}, 6e4);
+			this.slackRetryTimers.set(group.appToken, timer);
+		}
+	}
 	ensureHost(agentId, cfg) {
 		let host = this.hosts.get(agentId);
 		if (host) return host;
@@ -83655,6 +84069,8 @@ var Daemon = class Daemon {
 		}
 		for (const t of this.cancelTimers.values()) this.clock.clearTimeout(t);
 		this.cancelTimers.clear();
+		for (const t of this.slackRetryTimers.values()) this.clock.clearTimeout(t);
+		this.slackRetryTimers.clear();
 		this.metrics?.stop();
 		await this.watcher?.close();
 		await this.drainForShutdown();
@@ -83697,4 +84113,4 @@ async function runForeground(opts, deps = {}) {
 //#endregion
 export { ClientTransport as n, runForeground as t };
 
-//# sourceMappingURL=run-foreground-BroK115h.js.map
+//# sourceMappingURL=run-foreground-CK2rQc1c.js.map