@alfe.ai/mcp-bundler 0.3.2 → 0.4.0

package/dist/index.js

@@ -89,6 +89,9 @@ var Connection = class Connection {
 	static RECONNECT_BACKOFF_MAX_MS = 3e4;
 	onUnexpectedClose;
 	onStderrLine;
+	connectTimeoutMs;
+	/** Whether any connect has ever been attempted — drives the eager retry sweep. */
+	connectAttempted = false;
 	constructor(params) {
 		this.name = params.name;
 		this.config = params.config;
@@ -96,6 +99,7 @@ var Connection = class Connection {
 		this.logger = params.logger;
 		this.onUnexpectedClose = params.onUnexpectedClose;
 		this.onStderrLine = params.onStderrLine;
+		this.connectTimeoutMs = params.connectTimeoutMs ?? 0;
 	}
 	/** Returns the most recent known tool list. May be empty if the server hasn't connected yet. */
 	snapshotTools() {
@@ -117,6 +121,15 @@ var Connection = class Connection {
 	lastErrorMessage() {
 		return this.lastError;
 	}
+	/**
+	* Whether a connect was ever attempted (success or failure). A reconciled
+	* connection that was never warmed has neither a client nor a `lastError` —
+	* this flag lets an eager host's retry sweep find it without also
+	* resurrecting cleanly-closed (idle-reaped) connections.
+	*/
+	hasConnectAttempted() {
+		return this.connectAttempted;
+	}
 	/** Idle timestamp for reaping. */
 	idleSinceMs() {
 		return Date.now() - this.lastUsedAt;
@@ -135,23 +148,33 @@ var Connection = class Connection {
 		return this.connectInFlight;
 	}
 	async connectAndDiscover() {
+		this.connectAttempted = true;
 		const safeConfig = "command" in this.config ? {
 			...this.config,
 			env: sanitizeStdioEnv(this.config.env)
 		} : this.config;
 		this.logger?.debug(`[mcp-bundler] connecting server "${this.name}"`);
-		let client;
-		try {
-			client = await this.deps.connect(safeConfig, {
+		const attempt = (async () => {
+			const c = await this.deps.connect(safeConfig, {
 				serverName: this.name,
 				onStderrLine: this.onStderrLine
 			});
-			const advertised = await client.listTools();
-			const connected = client;
-			this.client = connected;
+			try {
+				return {
+					client: c,
+					advertised: await c.listTools()
+				};
+			} catch (err) {
+				await c.close().catch(() => void 0);
+				throw err;
+			}
+		})();
+		try {
+			const { client, advertised } = await this.raceConnectTimeout(attempt);
+			this.client = client;
 			this.closing = false;
-			connected.onClose?.(() => {
-				this.handleUnexpectedClose(connected);
+			client.onClose?.(() => {
+				this.handleUnexpectedClose(client);
 			});
 			this.tools = advertised.map((t) => ({
 				prefixed: buildNamespacedToolName(this.name, t.name),
@@ -167,7 +190,7 @@ var Connection = class Connection {
 			this.reconnectBlockedUntilMs = 0;
 			this.logger?.info(`[mcp-bundler] server "${this.name}" connected, ${this.tools.length.toString()} tool(s)`);
 		} catch (err) {
-			if (client) await client.close().catch(() => void 0);
+			attempt.then(({ client }) => client.close()).catch(() => void 0);
 			this.consecutiveFailures += 1;
 			this.lastError = err instanceof Error ? err.message : String(err);
 			const backoff = Math.min(Connection.RECONNECT_BACKOFF_BASE_MS * 2 ** (this.consecutiveFailures - 1), Connection.RECONNECT_BACKOFF_MAX_MS);
@@ -175,6 +198,23 @@ var Connection = class Connection {
 			throw err;
 		}
 	}
+	/** Race the attempt against `connectTimeoutMs`; 0 disables the bound. */
+	async raceConnectTimeout(attempt) {
+		const ms = this.connectTimeoutMs;
+		if (ms <= 0) return attempt;
+		let timer;
+		const timeout = new Promise((_, reject) => {
+			timer = setTimeout(() => {
+				reject(/* @__PURE__ */ new Error(`server "${this.name}" connect timed out after ${ms.toString()}ms — spawned but did not complete the MCP handshake/discovery`));
+			}, ms);
+			if (typeof timer === "object" && "unref" in timer) timer.unref();
+		});
+		try {
+			return await Promise.race([attempt, timeout]);
+		} finally {
+			clearTimeout(timer);
+		}
+	}
 	/**
 	* Handle an unexpected transport close (crash / network drop). Clears the
 	* dead client + tools so the next `ensureConnected` re-spawns. No-op if we
@@ -335,6 +375,7 @@ async function defaultConnect(server, ctx) {
 const DEFAULT_IDLE_TTL_MS = 600 * 1e3;
 const DEFAULT_IDLE_SWEEP_INTERVAL_MS = 60 * 1e3;
 const DEFAULT_RETRY_SWEEP_INTERVAL_MS = 60 * 1e3;
+const DEFAULT_CONNECT_TIMEOUT_MS = 120 * 1e3;
 /** First text content of an error result, for host error reporting. */
 function extractErrorText(result) {
 	for (const item of result.content) if (item.type === "text" && typeof item.text === "string") return item.text.slice(0, 500);
@@ -358,6 +399,8 @@ var McpBundler = class {
 	retrySweepIntervalMs;
 	retrySweepTimer;
 	retrySweepInFlight = false;
+	connectTimeoutMs;
+	retryNeverConnected;
 	deps;
 	onToolError;
 	onServerCrash;
@@ -369,6 +412,8 @@ var McpBundler = class {
 		this.idleTtlMs = opts.idleTtlMs ?? DEFAULT_IDLE_TTL_MS;
 		this.idleSweepIntervalMs = opts.idleSweepIntervalMs ?? DEFAULT_IDLE_SWEEP_INTERVAL_MS;
 		this.retrySweepIntervalMs = opts.retrySweepIntervalMs ?? DEFAULT_RETRY_SWEEP_INTERVAL_MS;
+		this.connectTimeoutMs = opts.connectTimeoutMs ?? DEFAULT_CONNECT_TIMEOUT_MS;
+		this.retryNeverConnected = opts.retryNeverConnected ?? false;
 		this.deps = deps ?? { connect: defaultConnect };
 		this.onToolError = opts.onToolError;
 		this.onServerCrash = opts.onServerCrash;
@@ -385,6 +430,7 @@ var McpBundler = class {
 			config,
 			deps: this.deps,
 			logger: this.logger,
+			connectTimeoutMs: config.connectionTimeoutMs ?? this.connectTimeoutMs,
 			...crash ? { onUnexpectedClose: () => {
 				crash(name);
 			} } : {},
@@ -503,15 +549,20 @@ var McpBundler = class {
 	* 500ms → 30s cap). A server that keeps `exit(1)`-ing fast-fails while in
 	* backoff, so repeated sweeps are cheap and never become a tight crash-loop
 	* — the backoff widens with each failure. Servers that connect on their
-	* first warm, and lazily-added servers that never warmed (no `lastError`),
-	* are left alone.
+	* first warm are left alone, as are cleanly-closed (idle-reaped) ones.
+	*
+	* Lazily-added servers that were NEVER attempted (no client, no
+	* `lastError`) are also left alone by default — but with
+	* `retryNeverConnected` (the daemon's eager mode) the sweep picks them up,
+	* so a server added after the host's warmup pass self-heals within one
+	* sweep instead of stranding its tools until a restart.
 	*
 	* Returns the statuses of the servers it attempted (empty if none needed a
 	* retry). Never throws — per-server failures are reflected in the status.
 	*/
 	async retryFailed() {
 		if (this.disposed) return [];
-		const targets = Array.from(this.connections.values()).filter((conn) => !conn.isConnected() && conn.lastErrorMessage() !== void 0);
+		const targets = Array.from(this.connections.values()).filter((conn) => !conn.isConnected() && (conn.lastErrorMessage() !== void 0 || this.retryNeverConnected && !conn.hasConnectAttempted()));
 		if (targets.length === 0) return [];
 		return (await Promise.allSettled(targets.map(async (conn) => {
 			try {
@@ -990,8 +1041,11 @@ var Manager = class {
 	/**
 	* Register or overwrite a server entry. Mutation lands in the store
 	* synchronously; if a bundler has been attached via `loadIntoBundler`,
-	* it gets re-reconciled in the background (errors logged, never
-	* thrown — the store is the source of truth, the bundler is derived).
+	* it is re-reconciled BEFORE `onChange` listeners fire (errors logged,
+	* never thrown — the store is the source of truth, the bundler is
+	* derived). The ordering is load-bearing: the daemon's `onChange`
+	* handler warms the bundler's current connections, so the just-added
+	* server must already have its Connection object or it is never warmed.
 	*/
 	async addServer(config, opts) {
 		if (!opts.id) throw new Error("Manager.addServer: id is required");
@@ -1012,9 +1066,8 @@ var Manager = class {
 				}
 			};
 		});
-		this.scheduleBundlerReconcile();
+		await this.reconcileBundlerLogged();
 		this.fireChange();
-		return Promise.resolve();
 	}
 	/**
 	* Remove a single server entry. No-op if the id isn't in the store.
@@ -1022,17 +1075,17 @@ var Manager = class {
 	* when supplied — the CLI uses this to guard `alfe mcp remove` from
 	* accidentally clobbering integration- or cli-owned entries.
 	*/
-	removeServer(id, opts = {}) {
+	async removeServer(id, opts = {}) {
 		const existing = lookupEntry(this.store.read().servers, id);
-		if (!existing) return Promise.resolve(false);
-		if (opts.expectedOwner && existing.owner !== opts.expectedOwner) return Promise.reject(/* @__PURE__ */ new Error(`Manager.removeServer: server "${id}" is owned by "${existing.owner}", not "${opts.expectedOwner}"`));
+		if (!existing) return false;
+		if (opts.expectedOwner && existing.owner !== opts.expectedOwner) throw new Error(`Manager.removeServer: server "${id}" is owned by "${existing.owner}", not "${opts.expectedOwner}"`);
 		this.store.update((cur) => ({
 			...cur,
 			servers: Object.fromEntries(Object.entries(cur.servers).filter(([k]) => k !== id))
 		}));
-		this.scheduleBundlerReconcile();
+		await this.reconcileBundlerLogged();
 		this.fireChange();
-		return Promise.resolve(true);
+		return true;
 	}
 	/** Drop every entry whose owner matches — used by integration uninstall. */
 	async removeServersByOwner(owner) {
@@ -1048,10 +1101,10 @@ var Manager = class {
 			};
 		});
 		if (removed.length > 0) {
-			this.scheduleBundlerReconcile();
+			await this.reconcileBundlerLogged();
 			this.fireChange();
 		}
-		return Promise.resolve(removed);
+		return removed;
 	}
 	/** Read-only snapshot for `alfe mcp list` and similar UIs. */
 	listServers() {
@@ -1121,11 +1174,19 @@ var Manager = class {
 		this.bundler = void 0;
 		return Promise.resolve();
 	}
-	scheduleBundlerReconcile() {
+	/**
+	* Awaited by every mutator so `onChange` listeners observe a bundler
+	* that already contains the mutation. Reconcile failures are logged,
+	* never thrown — a mutation must not fail because the derived bundler
+	* hiccuped.
+	*/
+	async reconcileBundlerLogged() {
 		if (!this.bundler) return;
-		this.reconcileBundler().catch((err) => {
+		try {
+			await this.reconcileBundler();
+		} catch (err) {
 			this.logger?.warn("[mcp-bundler/manager] bundler reconcile failed", { err: errMsg(err) });
-		});
+		}
 	}
 	async reconcileBundler() {
 		if (!this.bundler) return;