muxed 0.1.0

package/dist/cli.mjs

@@ -0,0 +1,3660 @@
+import { createRequire } from "node:module";
+import fs from "node:fs";
+import path from "node:path";
+import os from "node:os";
+import { z } from "zod/v4";
+import { Client } from "@modelcontextprotocol/sdk/client/index.js";
+import { StdioClientTransport } from "@modelcontextprotocol/sdk/client/stdio.js";
+import { SSEClientTransport, SseError } from "@modelcontextprotocol/sdk/client/sse.js";
+import { StreamableHTTPClientTransport, StreamableHTTPError } from "@modelcontextprotocol/sdk/client/streamableHttp.js";
+import { UnauthorizedError } from "@modelcontextprotocol/sdk/client/auth.js";
+import { LATEST_PROTOCOL_VERSION } from "@modelcontextprotocol/sdk/types.js";
+import { execFile, fork } from "node:child_process";
+import http from "node:http";
+import { compile } from "json-schema-to-typescript";
+import net from "node:net";
+import { Command } from "commander";
+import * as readline from "node:readline/promises";
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+var __defProp = Object.defineProperty;
+var __exportAll = (all, no_symbols) => {
+	let target = {};
+	for (var name in all) __defProp(target, name, {
+		get: all[name],
+		enumerable: true
+	});
+	if (!no_symbols) __defProp(target, Symbol.toStringTag, { value: "Module" });
+	return target;
+};
+const StdioServerConfigSchema = z.object({
+	command: z.string(),
+	args: z.array(z.string()).optional(),
+	env: z.record(z.string(), z.string()).optional(),
+	cwd: z.string().optional()
+});
+const ReconnectionSchema = z.object({
+	maxDelay: z.number().optional(),
+	initialDelay: z.number().optional(),
+	growFactor: z.number().optional(),
+	maxRetries: z.number().optional()
+});
+const ClientCredentialsAuthSchema = z.object({
+	type: z.literal("client_credentials"),
+	clientId: z.string(),
+	clientSecret: z.string(),
+	scope: z.string().optional()
+});
+const AuthorizationCodeAuthSchema = z.object({
+	type: z.literal("authorization_code"),
+	clientId: z.string().optional(),
+	clientSecret: z.string().optional(),
+	scope: z.string().optional(),
+	callbackPort: z.number().int().min(0).max(65535).optional()
+});
+const OAuthConfigSchema = z.union([ClientCredentialsAuthSchema, AuthorizationCodeAuthSchema]);
+const HttpServerConfigSchema = z.object({
+	url: z.string(),
+	transport: z.enum(["streamable-http", "sse"]).optional(),
+	headers: z.record(z.string(), z.string()).optional(),
+	sessionId: z.string().optional(),
+	reconnection: ReconnectionSchema.optional(),
+	auth: OAuthConfigSchema.optional()
+});
+const ServerConfigSchema = z.union([StdioServerConfigSchema, HttpServerConfigSchema]);
+const HttpListenerSchema = z.object({
+	enabled: z.boolean().optional(),
+	port: z.number().optional(),
+	host: z.string().optional()
+});
+const DaemonConfigSchema = z.object({
+	idleTimeout: z.number().optional(),
+	connectTimeout: z.number().optional(),
+	requestTimeout: z.number().optional(),
+	healthCheckInterval: z.number().optional(),
+	maxRestartAttempts: z.number().optional(),
+	maxTotalTimeout: z.number().optional(),
+	taskExpiryTimeout: z.number().optional(),
+	logLevel: z.enum([
+		"debug",
+		"info",
+		"warn",
+		"error"
+	]).optional(),
+	shutdownTimeout: z.number().optional(),
+	http: HttpListenerSchema.optional()
+});
+const TooldConfigSchema = z.object({
+	mcpServers: z.record(z.string(), ServerConfigSchema),
+	daemon: DaemonConfigSchema.optional(),
+	mergeClaudeConfig: z.boolean().optional()
+});
+function getClaudeDesktopConfigPath() {
+	const platform = os.platform();
+	const home = os.homedir();
+	if (platform === "darwin") return path.join(home, "Library", "Application Support", "Claude", "claude_desktop_config.json");
+	if (platform === "linux") return path.join(home, ".config", "Claude", "claude_desktop_config.json");
+	return null;
+}
+function mergeClaudeDesktopServers(servers) {
+	const configPath = getClaudeDesktopConfigPath();
+	if (!configPath || !fs.existsSync(configPath)) return servers;
+	try {
+		const claudeServers = JSON.parse(fs.readFileSync(configPath, "utf-8")).mcpServers;
+		if (!claudeServers || typeof claudeServers !== "object") return servers;
+		return {
+			...claudeServers,
+			...servers
+		};
+	} catch {
+		return servers;
+	}
+}
+const DAEMON_DEFAULTS = {
+	idleTimeout: 3e5,
+	connectTimeout: 3e4,
+	requestTimeout: 6e4,
+	healthCheckInterval: 3e4,
+	maxRestartAttempts: -1,
+	maxTotalTimeout: 3e5,
+	taskExpiryTimeout: 36e5,
+	logLevel: "info",
+	shutdownTimeout: 1e4
+};
+function getGlobalConfigPath() {
+	return path.join(os.homedir(), ".config", "toold", "config.json");
+}
+function findConfigFile(configPath) {
+	if (configPath) {
+		if (!fs.existsSync(configPath)) throw new Error(`Config file not found: ${configPath}`);
+		return configPath;
+	}
+	const cwdConfig = path.join(process.cwd(), "toold.config.json");
+	if (fs.existsSync(cwdConfig)) return cwdConfig;
+	const homeConfig = getGlobalConfigPath();
+	if (fs.existsSync(homeConfig)) return homeConfig;
+	return null;
+}
+function validateServerConfigs(config) {
+	for (const [name, serverConfig] of Object.entries(config.mcpServers)) {
+		const hasCommand = "command" in serverConfig;
+		const hasUrl = "url" in serverConfig;
+		if (!hasCommand && !hasUrl) throw new Error(`Server "${name}": must have either "command" (stdio) or "url" (HTTP) property`);
+	}
+}
+function loadConfig(configPath) {
+	const filePath = findConfigFile(configPath);
+	const config = filePath ? parseConfigFile(filePath) : { mcpServers: {} };
+	const globalConfigPath = getGlobalConfigPath();
+	if ((!filePath || path.resolve(filePath) !== path.resolve(globalConfigPath)) && fs.existsSync(globalConfigPath)) try {
+		const globalRaw = JSON.parse(fs.readFileSync(globalConfigPath, "utf-8"));
+		const globalResult = TooldConfigSchema.safeParse(globalRaw);
+		if (globalResult.success) config.mcpServers = {
+			...globalResult.data.mcpServers,
+			...config.mcpServers
+		};
+	} catch {}
+	if (config.mergeClaudeConfig) config.mcpServers = mergeClaudeDesktopServers(config.mcpServers);
+	validateServerConfigs(config);
+	config.daemon = {
+		...DAEMON_DEFAULTS,
+		...config.daemon,
+		http: {
+			enabled: false,
+			port: 3100,
+			host: "127.0.0.1",
+			...config.daemon?.http
+		}
+	};
+	return config;
+}
+function parseConfigFile(filePath) {
+	const raw = fs.readFileSync(filePath, "utf-8");
+	let parsed;
+	try {
+		parsed = JSON.parse(raw);
+	} catch {
+		throw new Error(`Invalid JSON in config file: ${filePath}`);
+	}
+	const result = TooldConfigSchema.safeParse(parsed);
+	if (!result.success) throw new Error(`Invalid config: ${z.prettifyError(result.error)}`);
+	return result.data;
+}
+function isStdioConfig(config) {
+	return "command" in config;
+}
+function isHttpConfig(config) {
+	return "url" in config;
+}
+var paths_exports = /* @__PURE__ */ __exportAll({
+	ensureTooldDir: () => ensureTooldDir,
+	getLogPath: () => getLogPath,
+	getPidPath: () => getPidPath,
+	getSocketPath: () => getSocketPath,
+	getTooldDir: () => getTooldDir
+});
+function getTooldDir() {
+	return path.join(os.homedir(), ".toold");
+}
+function getSocketPath() {
+	return path.join(getTooldDir(), "toold.sock");
+}
+function getPidPath() {
+	return path.join(getTooldDir(), "toold.pid");
+}
+function getLogPath() {
+	return path.join(getTooldDir(), "toold.log");
+}
+function ensureTooldDir() {
+	fs.mkdirSync(getTooldDir(), { recursive: true });
+}
+const LOG_LEVELS = {
+	debug: 0,
+	info: 1,
+	warn: 2,
+	error: 3
+};
+const MAX_LOG_SIZE = 10 * 1024 * 1024;
+var Logger = class {
+	level;
+	logPath;
+	fd = null;
+	writeToStderr;
+	constructor(opts) {
+		this.level = opts?.level ?? "info";
+		this.logPath = opts?.logPath ?? getLogPath();
+		this.writeToStderr = opts?.stderr ?? false;
+	}
+	openFile() {
+		if (this.fd !== null) return;
+		try {
+			this.fd = fs.openSync(this.logPath, "a");
+		} catch {}
+	}
+	rotateIfNeeded() {
+		if (this.fd === null) return;
+		try {
+			if (fs.fstatSync(this.fd).size > MAX_LOG_SIZE) {
+				fs.closeSync(this.fd);
+				fs.truncateSync(this.logPath, 0);
+				this.fd = fs.openSync(this.logPath, "a");
+			}
+		} catch {}
+	}
+	formatMessage(level, message, server) {
+		const ts = (/* @__PURE__ */ new Date()).toISOString();
+		const serverTag = server ? ` [${server}]` : "";
+		return `${ts} ${level.toUpperCase()}${serverTag} ${message}`;
+	}
+	log(level, message, server) {
+		if (LOG_LEVELS[level] < LOG_LEVELS[this.level]) return;
+		const formatted = this.formatMessage(level, message, server);
+		if (this.writeToStderr) process.stderr.write(formatted + "\n");
+		this.openFile();
+		if (this.fd !== null) {
+			this.rotateIfNeeded();
+			try {
+				fs.writeSync(this.fd, formatted + "\n");
+			} catch {}
+		}
+	}
+	debug(message, server) {
+		this.log("debug", message, server);
+	}
+	info(message, server) {
+		this.log("info", message, server);
+	}
+	warn(message, server) {
+		this.log("warn", message, server);
+	}
+	error(message, server) {
+		this.log("error", message, server);
+	}
+	setLevel(level) {
+		this.level = level;
+	}
+	close() {
+		if (this.fd !== null) {
+			try {
+				fs.closeSync(this.fd);
+			} catch {}
+			this.fd = null;
+		}
+	}
+};
+let defaultLogger;
+function getLogger() {
+	if (!defaultLogger) defaultLogger = new Logger();
+	return defaultLogger;
+}
+function initLogger(opts) {
+	if (defaultLogger) defaultLogger.close();
+	defaultLogger = new Logger(opts);
+	return defaultLogger;
+}
+function sanitizeName(name) {
+	return name.replace(/[^a-zA-Z0-9_-]/g, "_");
+}
+function getAuthDir() {
+	return path.join(getTooldDir(), "auth");
+}
+function getStorePath(serverName) {
+	return path.join(getAuthDir(), `${sanitizeName(serverName)}.json`);
+}
+function ensureAuthDir() {
+	fs.mkdirSync(getAuthDir(), {
+		recursive: true,
+		mode: 448
+	});
+}
+function readStore(serverName) {
+	const filePath = getStorePath(serverName);
+	try {
+		const raw = fs.readFileSync(filePath, "utf-8");
+		return JSON.parse(raw);
+	} catch {
+		return {};
+	}
+}
+function writeStore(serverName, data) {
+	ensureAuthDir();
+	const filePath = getStorePath(serverName);
+	fs.writeFileSync(filePath, JSON.stringify(data, null, 2), { mode: 384 });
+}
+var TokenStore = class {
+	constructor(serverName) {
+		this.serverName = serverName;
+	}
+	getTokens() {
+		return readStore(this.serverName).tokens;
+	}
+	saveTokens(tokens) {
+		const data = readStore(this.serverName);
+		data.tokens = tokens;
+		writeStore(this.serverName, data);
+	}
+	getClientInformation() {
+		return readStore(this.serverName).clientInformation;
+	}
+	saveClientInformation(info) {
+		const data = readStore(this.serverName);
+		data.clientInformation = info;
+		writeStore(this.serverName, data);
+	}
+	getCodeVerifier() {
+		return readStore(this.serverName).codeVerifier;
+	}
+	saveCodeVerifier(verifier) {
+		const data = readStore(this.serverName);
+		data.codeVerifier = verifier;
+		writeStore(this.serverName, data);
+	}
+	clearTokens() {
+		const data = readStore(this.serverName);
+		delete data.tokens;
+		writeStore(this.serverName, data);
+	}
+	clearClientInformation() {
+		const data = readStore(this.serverName);
+		delete data.clientInformation;
+		writeStore(this.serverName, data);
+	}
+	clearCodeVerifier() {
+		const data = readStore(this.serverName);
+		delete data.codeVerifier;
+		writeStore(this.serverName, data);
+	}
+	clearAll() {
+		const filePath = getStorePath(this.serverName);
+		try {
+			fs.unlinkSync(filePath);
+		} catch {}
+	}
+	hasTokens() {
+		return readStore(this.serverName).tokens !== void 0;
+	}
+};
+var ClientCredentialsProvider = class {
+	store;
+	config;
+	constructor(config, serverName) {
+		this.config = config;
+		this.store = new TokenStore(serverName);
+	}
+	get redirectUrl() {}
+	get clientMetadata() {
+		return {
+			redirect_uris: [],
+			token_endpoint_auth_method: "client_secret_basic",
+			grant_types: ["client_credentials"],
+			response_types: [],
+			client_name: "toold"
+		};
+	}
+	clientInformation() {
+		return {
+			client_id: this.config.clientId,
+			client_secret: this.config.clientSecret
+		};
+	}
+	async tokens() {
+		return this.store.getTokens();
+	}
+	async saveTokens(tokens) {
+		this.store.saveTokens(tokens);
+	}
+	redirectToAuthorization() {
+		throw new Error("Client credentials flow does not use authorization redirects");
+	}
+	saveCodeVerifier() {}
+	codeVerifier() {
+		return "";
+	}
+	prepareTokenRequest(scope) {
+		const params = new URLSearchParams();
+		params.set("grant_type", "client_credentials");
+		const effectiveScope = scope ?? this.config.scope;
+		if (effectiveScope) params.set("scope", effectiveScope);
+		return params;
+	}
+	invalidateCredentials(scope) {
+		if (scope === "all" || scope === "tokens") this.store.clearTokens();
+	}
+};
+function exec(cmd, args) {
+	return new Promise((resolve) => {
+		execFile(cmd, args, { timeout: 5e3 }, (err) => {
+			resolve(!err);
+		});
+	});
+}
+function openUrl(url) {
+	const platform = process.platform;
+	if (platform === "darwin") execFile("open", [url]);
+	else if (platform === "win32") execFile("cmd", [
+		"/c",
+		"start",
+		"",
+		url
+	]);
+	else execFile("xdg-open", [url]);
+}
+function openBrowser(url) {
+	openUrl(url);
+}
+async function notifyReauth(serverName, authUrl) {
+	const title = "toold";
+	const message = `Server "${serverName}" needs re-authorization`;
+	const platform = process.platform;
+	if (platform === "darwin") {
+		if (await exec("terminal-notifier", [
+			"-title",
+			title,
+			"-message",
+			message,
+			"-open",
+			authUrl
+		])) return;
+		await exec("osascript", ["-e", `display notification "${message}" with title "${title}"`]);
+		openUrl(authUrl);
+	} else if (platform === "linux") {
+		await exec("notify-send", [title, message]);
+		openUrl(authUrl);
+	} else openUrl(authUrl);
+}
+var AuthorizationCodeProvider = class {
+	store;
+	config;
+	_redirectUrl;
+	hadTokensBefore = false;
+	constructor(config, serverName) {
+		this.serverName = serverName;
+		this.config = config;
+		this.store = new TokenStore(serverName);
+		this.hadTokensBefore = this.store.hasTokens();
+	}
+	setRedirectUrl(port) {
+		this._redirectUrl = `http://127.0.0.1:${port}/oauth/callback`;
+	}
+	get redirectUrl() {
+		return this._redirectUrl;
+	}
+	get clientMetadata() {
+		return {
+			redirect_uris: [this._redirectUrl ?? "http://127.0.0.1/oauth/callback"],
+			token_endpoint_auth_method: this.config.clientSecret ? "client_secret_basic" : "none",
+			grant_types: ["authorization_code", "refresh_token"],
+			response_types: ["code"],
+			client_name: "toold",
+			scope: this.config.scope
+		};
+	}
+	clientInformation() {
+		if (this.config.clientId) return {
+			client_id: this.config.clientId,
+			...this.config.clientSecret ? { client_secret: this.config.clientSecret } : {}
+		};
+		return this.store.getClientInformation();
+	}
+	saveClientInformation(info) {
+		this.store.saveClientInformation(info);
+	}
+	async tokens() {
+		return this.store.getTokens();
+	}
+	async saveTokens(tokens) {
+		this.store.saveTokens(tokens);
+	}
+	async redirectToAuthorization(authorizationUrl) {
+		const url = authorizationUrl.toString();
+		if (this.hadTokensBefore) {
+			getLogger().info(`Re-authorization needed for "${this.serverName}"`, this.serverName);
+			await notifyReauth(this.serverName, url);
+		} else {
+			getLogger().info(`Opening browser for authorization of "${this.serverName}"`, this.serverName);
+			openBrowser(url);
+		}
+	}
+	saveCodeVerifier(codeVerifier) {
+		this.store.saveCodeVerifier(codeVerifier);
+	}
+	codeVerifier() {
+		return this.store.getCodeVerifier() ?? "";
+	}
+	invalidateCredentials(scope) {
+		if (scope === "all" || scope === "tokens") {
+			if (this.store.hasTokens()) this.hadTokensBefore = true;
+		}
+		switch (scope) {
+			case "all":
+				this.store.clearAll();
+				break;
+			case "client":
+				this.store.clearClientInformation();
+				break;
+			case "tokens":
+				this.store.clearTokens();
+				break;
+			case "verifier":
+				this.store.clearCodeVerifier();
+				break;
+		}
+	}
+};
+const SUCCESS_HTML = `<!DOCTYPE html>
+<html><head><title>toold - Authorization Successful</title></head>
+<body style="font-family:system-ui;text-align:center;padding:60px">
+<h1>Authorization Successful</h1>
+<p>You can close this tab and return to toold.</p>
+</body></html>`;
+const ERROR_HTML = (msg) => `<!DOCTYPE html>
+<html><head><title>toold - Authorization Error</title></head>
+<body style="font-family:system-ui;text-align:center;padding:60px">
+<h1>Authorization Error</h1>
+<p>${msg}</p>
+</body></html>`;
+var CallbackServer = class {
+	server;
+	_port;
+	start(port = 0, timeoutMs = 3e5) {
+		return new Promise((resolve, reject) => {
+			let settled = false;
+			let timer;
+			const cleanup = () => {
+				if (timer) {
+					clearTimeout(timer);
+					timer = void 0;
+				}
+				this.close();
+			};
+			this.server = http.createServer((req, res) => {
+				if (settled) {
+					res.writeHead(400);
+					res.end();
+					return;
+				}
+				const url = new URL(req.url ?? "/", `http://127.0.0.1`);
+				if (url.pathname !== "/oauth/callback") {
+					res.writeHead(404);
+					res.end("Not found");
+					return;
+				}
+				const error = url.searchParams.get("error");
+				if (error) {
+					const desc = url.searchParams.get("error_description") ?? error;
+					res.writeHead(400, { "Content-Type": "text/html" });
+					res.end(ERROR_HTML(desc));
+					settled = true;
+					cleanup();
+					reject(/* @__PURE__ */ new Error(`OAuth error: ${desc}`));
+					return;
+				}
+				const code = url.searchParams.get("code");
+				if (!code) {
+					res.writeHead(400, { "Content-Type": "text/html" });
+					res.end(ERROR_HTML("Missing authorization code"));
+					settled = true;
+					cleanup();
+					reject(/* @__PURE__ */ new Error("Missing authorization code in callback"));
+					return;
+				}
+				const state = url.searchParams.get("state") ?? void 0;
+				res.writeHead(200, { "Content-Type": "text/html" });
+				res.end(SUCCESS_HTML);
+				settled = true;
+				cleanup();
+				resolve({
+					code,
+					state
+				});
+			});
+			this.server.listen(port, "127.0.0.1", () => {
+				const addr = this.server.address();
+				if (addr && typeof addr === "object") this._port = addr.port;
+			});
+			this.server.on("error", (err) => {
+				if (!settled) {
+					settled = true;
+					cleanup();
+					reject(err);
+				}
+			});
+			timer = setTimeout(() => {
+				if (!settled) {
+					settled = true;
+					cleanup();
+					reject(/* @__PURE__ */ new Error("OAuth callback timed out"));
+				}
+			}, timeoutMs);
+		});
+	}
+	get port() {
+		return this._port;
+	}
+	async waitForPort() {
+		if (this._port !== void 0) return this._port;
+		return new Promise((resolve, reject) => {
+			if (!this.server) {
+				reject(/* @__PURE__ */ new Error("Callback server not started"));
+				return;
+			}
+			this.server.once("listening", () => {
+				const addr = this.server.address();
+				if (addr && typeof addr === "object") {
+					this._port = addr.port;
+					resolve(this._port);
+				} else reject(/* @__PURE__ */ new Error("Could not determine callback server port"));
+			});
+		});
+	}
+	close() {
+		if (this.server) {
+			this.server.close();
+			this.server = void 0;
+		}
+	}
+};
+function createAuthProvider(config, serverName) {
+	switch (config.type) {
+		case "client_credentials": return new ClientCredentialsProvider(config, serverName);
+		case "authorization_code": return new AuthorizationCodeProvider(config, serverName);
+	}
+}
+var ServerManager = class {
+	client;
+	transport;
+	status = "closed";
+	error;
+	serverInfo;
+	capabilities;
+	protocolVersion;
+	instructions;
+	tools = [];
+	resources = [];
+	prompts = [];
+	healthTimer;
+	consecutiveFailures = 0;
+	lastHealthCheck;
+	restartCount = 0;
+	restartTimer;
+	stopped = false;
+	connectTimeout;
+	healthCheckInterval;
+	maxRestartAttempts;
+	onHealthChange;
+	constructor(name, config, options) {
+		this.name = name;
+		this.config = config;
+		this.connectTimeout = options?.connectTimeout;
+		this.healthCheckInterval = options?.healthCheckInterval ?? 3e4;
+		this.maxRestartAttempts = options?.maxRestartAttempts ?? -1;
+	}
+	setHealthCallback(cb) {
+		this.onHealthChange = cb;
+	}
+	emitHealthChange(newStatus, error) {
+		if (this.onHealthChange) this.onHealthChange(this.name, newStatus, error);
+	}
+	async connect(connectTimeout) {
+		this.status = "connecting";
+		this.error = void 0;
+		const timeout = connectTimeout ?? this.connectTimeout;
+		try {
+			if (isStdioConfig(this.config)) this.transport = new StdioClientTransport({
+				command: this.config.command,
+				args: this.config.args,
+				env: this.config.env ? {
+					...process.env,
+					...this.config.env
+				} : void 0,
+				cwd: this.config.cwd
+			});
+			else if (isHttpConfig(this.config) && this.config.transport === "sse") {
+				if (this.config.auth?.type === "authorization_code") {
+					await this.connectWithOAuth(this.config, this.config.auth, timeout);
+					return;
+				}
+				const opts = {};
+				if (this.config.headers) opts.requestInit = { headers: this.config.headers };
+				if (this.config.auth) opts.authProvider = createAuthProvider(this.config.auth, this.name);
+				this.transport = new SSEClientTransport(new URL(this.config.url), opts);
+			} else {
+				const httpConfig = this.config;
+				const opts = {};
+				if (httpConfig.headers) opts.requestInit = { headers: httpConfig.headers };
+				if (httpConfig.sessionId) opts.sessionId = httpConfig.sessionId;
+				if (httpConfig.reconnection) {
+					const r = httpConfig.reconnection;
+					opts.reconnectionOptions = {
+						maxReconnectionDelay: r.maxDelay ?? 3e4,
+						initialReconnectionDelay: r.initialDelay ?? 1e3,
+						reconnectionDelayGrowFactor: r.growFactor ?? 1.5,
+						maxRetries: r.maxRetries ?? 2
+					};
+				}
+				if (httpConfig.auth?.type === "authorization_code") {
+					await this.connectWithOAuth(httpConfig, httpConfig.auth, timeout);
+					return;
+				}
+				if (httpConfig.auth) opts.authProvider = createAuthProvider(httpConfig.auth, this.name);
+				this.transport = new StreamableHTTPClientTransport(new URL(httpConfig.url), opts);
+			}
+			this.client = this.createClient();
+			const requestOptions = timeout ? { signal: AbortSignal.timeout(timeout) } : void 0;
+			try {
+				await this.client.connect(this.transport, requestOptions);
+			} catch (err) {
+				if ((err instanceof UnauthorizedError || err instanceof StreamableHTTPError && err.code === 401 || err instanceof SseError && err.code === 401) && isHttpConfig(this.config) && !this.config.auth) {
+					getLogger().info("Server requires auth, initiating OAuth flow...", this.name);
+					await this.connectWithOAuth(this.config, { type: "authorization_code" }, timeout);
+					return;
+				}
+				throw err;
+			}
+			await this.finishConnect();
+		} catch (err) {
+			this.status = "error";
+			this.error = err instanceof Error ? err.message : String(err);
+			this.emitHealthChange("error", this.error);
+			getLogger().error(`Connection failed: ${this.error}`, this.name);
+		}
+	}
+	createClient() {
+		const client = new Client({
+			name: "toold",
+			version: "0.1.0"
+		}, {
+			capabilities: { tasks: {
+				list: {},
+				cancel: {}
+			} },
+			listChanged: {
+				tools: {
+					autoRefresh: false,
+					onChanged: () => {
+						this.refreshTools().catch(() => {});
+					}
+				},
+				resources: {
+					autoRefresh: false,
+					onChanged: () => {
+						this.refreshResources().catch(() => {});
+					}
+				},
+				prompts: {
+					autoRefresh: false,
+					onChanged: () => {
+						this.refreshPrompts().catch(() => {});
+					}
+				}
+			}
+		});
+		client.onclose = () => {
+			const previousStatus = this.status;
+			if (this.status !== "error") this.status = "closed";
+			if (previousStatus === "connected" && !this.stopped) {
+				getLogger().warn("Connection closed unexpectedly, will attempt restart", this.name);
+				this.emitHealthChange("closed");
+				this.scheduleRestart();
+			}
+		};
+		return client;
+	}
+	async finishConnect() {
+		if (!this.client) return;
+		this.capabilities = this.client.getServerCapabilities();
+		this.serverInfo = this.client.getServerVersion();
+		this.instructions = this.client.getInstructions();
+		this.protocolVersion = (this.transport instanceof StreamableHTTPClientTransport ? this.transport.protocolVersion : void 0) ?? LATEST_PROTOCOL_VERSION;
+		this.status = "connected";
+		this.consecutiveFailures = 0;
+		await this.refreshTools();
+		await this.refreshResources();
+		await this.refreshPrompts();
+		this.startHealthChecks();
+		this.emitHealthChange("connected");
+		getLogger().info("Connected successfully", this.name);
+	}
+	async connectWithOAuth(httpConfig, authConfig, timeout) {
+		const callbackServer = new CallbackServer();
+		try {
+			const callbackPromise = callbackServer.start(authConfig.callbackPort ?? 0);
+			const port = await callbackServer.waitForPort();
+			const authProvider = new AuthorizationCodeProvider(authConfig, this.name);
+			authProvider.setRedirectUrl(port);
+			const createTransport = () => {
+				if (httpConfig.transport === "sse") {
+					const opts = {};
+					if (httpConfig.headers) opts.requestInit = { headers: httpConfig.headers };
+					opts.authProvider = authProvider;
+					return new SSEClientTransport(new URL(httpConfig.url), opts);
+				}
+				const opts = {};
+				if (httpConfig.headers) opts.requestInit = { headers: httpConfig.headers };
+				if (httpConfig.sessionId) opts.sessionId = httpConfig.sessionId;
+				if (httpConfig.reconnection) {
+					const r = httpConfig.reconnection;
+					opts.reconnectionOptions = {
+						maxReconnectionDelay: r.maxDelay ?? 3e4,
+						initialReconnectionDelay: r.initialDelay ?? 1e3,
+						reconnectionDelayGrowFactor: r.growFactor ?? 1.5,
+						maxRetries: r.maxRetries ?? 2
+					};
+				}
+				opts.authProvider = authProvider;
+				return new StreamableHTTPClientTransport(new URL(httpConfig.url), opts);
+			};
+			let transport = createTransport();
+			this.transport = transport;
+			this.client = this.createClient();
+			const requestOptions = timeout ? { signal: AbortSignal.timeout(timeout) } : void 0;
+			try {
+				await this.client.connect(transport, requestOptions);
+			} catch (err) {
+				if (err instanceof UnauthorizedError) {
+					getLogger().info("Authorization required, waiting for browser callback...", this.name);
+					const { code } = await callbackPromise;
+					await transport.finishAuth(code);
+					transport = createTransport();
+					this.transport = transport;
+					this.client = this.createClient();
+					await this.client.connect(transport, requestOptions);
+				} else throw err;
+			}
+			await this.finishConnect();
+		} finally {
+			callbackServer.close();
+		}
+	}
+	async disconnect() {
+		this.stopped = true;
+		this.stopHealthChecks();
+		if (this.restartTimer) {
+			clearTimeout(this.restartTimer);
+			this.restartTimer = void 0;
+		}
+		if (this.client) await this.client.close();
+		this.status = "closed";
+	}
+	startHealthChecks() {
+		this.stopHealthChecks();
+		if (this.healthCheckInterval <= 0) return;
+		this.healthTimer = setInterval(() => {
+			this.performHealthCheck().catch(() => {});
+		}, this.healthCheckInterval);
+	}
+	stopHealthChecks() {
+		if (this.healthTimer) {
+			clearInterval(this.healthTimer);
+			this.healthTimer = void 0;
+		}
+	}
+	async performHealthCheck() {
+		if (!this.client || this.status !== "connected") return;
+		this.lastHealthCheck = /* @__PURE__ */ new Date();
+		try {
+			await this.client.ping();
+			if (this.consecutiveFailures > 0) getLogger().info(`Health check recovered after ${this.consecutiveFailures} failures`, this.name);
+			this.consecutiveFailures = 0;
+		} catch (err) {
+			this.consecutiveFailures++;
+			const msg = err instanceof Error ? err.message : String(err);
+			getLogger().warn(`Health check failed (${this.consecutiveFailures} consecutive): ${msg}`, this.name);
+			if (this.consecutiveFailures >= 3) {
+				this.status = "error";
+				this.error = `Health check failed ${this.consecutiveFailures} times`;
+				this.emitHealthChange("error", this.error);
+				getLogger().error(`Marked as error after ${this.consecutiveFailures} failed pings`, this.name);
+				this.stopHealthChecks();
+				this.scheduleRestart();
+			}
+		}
+	}
+	scheduleRestart() {
+		if (this.stopped) return;
+		if (this.maxRestartAttempts >= 0 && this.restartCount >= this.maxRestartAttempts) {
+			getLogger().error(`Max restart attempts (${this.maxRestartAttempts}) reached, giving up`, this.name);
+			return;
+		}
+		const delay = Math.min(1e3 * Math.pow(2, this.restartCount), 6e4);
+		this.restartCount++;
+		getLogger().info(`Scheduling restart attempt ${this.restartCount} in ${delay}ms`, this.name);
+		this.restartTimer = setTimeout(() => {
+			this.restartTimer = void 0;
+			this.attemptRestart().catch(() => {});
+		}, delay);
+	}
+	async attemptRestart() {
+		if (this.stopped) return;
+		getLogger().info(`Attempting restart (attempt ${this.restartCount})`, this.name);
+		if (this.client) {
+			try {
+				await this.client.close();
+			} catch {}
+			this.client = void 0;
+			this.transport = void 0;
+		}
+		await this.connect(this.connectTimeout);
+		if (this.status === "connected") {
+			getLogger().info(`Restart successful after ${this.restartCount} attempts`, this.name);
+			this.restartCount = 0;
+		}
+		if (this.status === "error" && !this.stopped) this.scheduleRestart();
+	}
+	listTools() {
+		return this.tools;
+	}
+	async refreshTools() {
+		if (!this.client) return;
+		this.tools = (await this.client.listTools()).tools;
+	}
+	async callTool(name, args, timeout) {
+		if (!this.client) throw new Error(`Server "${this.name}" is not connected`);
+		const options = timeout ? { signal: AbortSignal.timeout(timeout) } : void 0;
+		return await this.client.callTool({
+			name,
+			arguments: args
+		}, void 0, options);
+	}
+	listResources() {
+		return this.resources;
+	}
+	async refreshResources() {
+		if (!this.client || !this.capabilities?.resources) return;
+		this.resources = (await this.client.listResources()).resources;
+	}
+	async readResource(uri) {
+		if (!this.client) throw new Error(`Server "${this.name}" is not connected`);
+		return await this.client.readResource({ uri });
+	}
+	listPrompts() {
+		return this.prompts;
+	}
+	async refreshPrompts() {
+		if (!this.client || !this.capabilities?.prompts) return;
+		this.prompts = (await this.client.listPrompts()).prompts;
+	}
+	async getPrompt(name, args) {
+		if (!this.client) throw new Error(`Server "${this.name}" is not connected`);
+		return await this.client.getPrompt({
+			name,
+			arguments: args
+		});
+	}
+	async complete(ref, argument) {
+		if (!this.client) throw new Error(`Server "${this.name}" is not connected`);
+		if (!this.capabilities?.completions) throw new Error(`Server "${this.name}" does not support completions`);
+		return await this.client.complete({
+			ref,
+			argument
+		});
+	}
+	async listTasks(cursor) {
+		if (!this.client) throw new Error(`Server "${this.name}" is not connected`);
+		if (!this.capabilities?.experimental?.tasks) throw new Error(`Server "${this.name}" does not support tasks`);
+		return await this.client.experimental.tasks.listTasks(cursor);
+	}
+	async getTask(taskId) {
+		if (!this.client) throw new Error(`Server "${this.name}" is not connected`);
+		return await this.client.experimental.tasks.getTask(taskId);
+	}
+	async getTaskResult(taskId) {
+		if (!this.client) throw new Error(`Server "${this.name}" is not connected`);
+		return await this.client.experimental.tasks.getTaskResult(taskId);
+	}
+	async cancelTask(taskId) {
+		if (!this.client) throw new Error(`Server "${this.name}" is not connected`);
+		return await this.client.experimental.tasks.cancelTask(taskId);
+	}
+	async callToolWithTask(name, args) {
+		if (!this.client) throw new Error(`Server "${this.name}" is not connected`);
+		const stream = this.client.experimental.tasks.callToolStream({
+			name,
+			arguments: args
+		});
+		for await (const message of stream) if (message.type === "taskCreated") return {
+			taskId: message.task.taskId,
+			status: message.task.status
+		};
+		throw new Error("No task created");
+	}
+	getStatus() {
+		return this.status;
+	}
+	getAuthStatus() {
+		if (!isHttpConfig(this.config)) return void 0;
+		if (this.config.auth) {
+			const store = new TokenStore(this.name);
+			return {
+				type: this.config.auth.type,
+				hasTokens: store.hasTokens()
+			};
+		}
+		if (new TokenStore(this.name).hasTokens()) return {
+			type: "authorization_code",
+			hasTokens: true
+		};
+	}
+	getState() {
+		return {
+			name: this.name,
+			config: this.config,
+			status: this.status,
+			error: this.error,
+			serverInfo: this.serverInfo,
+			capabilities: this.capabilities,
+			protocolVersion: this.protocolVersion,
+			instructions: this.instructions,
+			restartCount: this.restartCount,
+			lastHealthCheck: this.lastHealthCheck?.toISOString(),
+			consecutiveFailures: this.consecutiveFailures
+		};
+	}
+};
+var ServerPool = class {
+	servers = /* @__PURE__ */ new Map();
+	trackedTasks = /* @__PURE__ */ new Map();
+	taskExpiryTimer;
+	taskExpiryTimeout = 36e5;
+	async connectAll(config) {
+		const entries = Object.entries(config.mcpServers);
+		this.taskExpiryTimeout = config.daemon?.taskExpiryTimeout ?? 36e5;
+		for (const [name, serverConfig] of entries) {
+			const manager = new ServerManager(name, serverConfig, {
+				connectTimeout: config.daemon?.connectTimeout,
+				healthCheckInterval: config.daemon?.healthCheckInterval,
+				maxRestartAttempts: config.daemon?.maxRestartAttempts
+			});
+			manager.setHealthCallback((serverName, status, error) => {
+				this.onServerHealthChange(serverName, status, error);
+			});
+			this.servers.set(name, manager);
+		}
+		const results = await Promise.allSettled([...this.servers.values()].map((manager) => manager.connect(config.daemon?.connectTimeout)));
+		for (let i = 0; i < entries.length; i++) {
+			const entry = entries[i];
+			const result = results[i];
+			if (entry && result && result.status === "rejected") getLogger().error(`Server "${entry[0]}" failed to connect: ${result.reason}`, entry[0]);
+		}
+		this.startTaskExpiry();
+	}
+	async disconnectAll() {
+		this.stopTaskExpiry();
+		await Promise.allSettled([...this.servers.values()].map((manager) => manager.disconnect()));
+	}
+	onServerHealthChange(serverName, status, error) {
+		if (status === "closed" || status === "error") {
+			for (const [taskId, task] of this.trackedTasks) if (task.server === serverName && task.status === "active") {
+				task.status = "unreachable";
+				getLogger().warn(`Task ${taskId} marked as unreachable (server ${serverName} disconnected)`, serverName);
+			}
+		} else if (status === "connected") getLogger().info(`Server reconnected`, serverName);
+		if (error) getLogger().error(`Health change: ${status} - ${error}`, serverName);
+	}
+	trackTask(taskId, server) {
+		this.trackedTasks.set(taskId, {
+			taskId,
+			server,
+			status: "active",
+			createdAt: Date.now()
+		});
+	}
+	getTrackedTask(taskId) {
+		return this.trackedTasks.get(taskId);
+	}
+	startTaskExpiry() {
+		this.stopTaskExpiry();
+		this.taskExpiryTimer = setInterval(() => {
+			const now = Date.now();
+			for (const [taskId, task] of this.trackedTasks) if (now - task.createdAt > this.taskExpiryTimeout) {
+				this.trackedTasks.delete(taskId);
+				getLogger().info(`Expired stale task ${taskId}`, task.server);
+			}
+		}, 3e5);
+	}
+	stopTaskExpiry() {
+		if (this.taskExpiryTimer) {
+			clearInterval(this.taskExpiryTimer);
+			this.taskExpiryTimer = void 0;
+		}
+	}
+	getServer(name) {
+		return this.servers.get(name);
+	}
+	listServers() {
+		return [...this.servers.values()].map((manager) => manager.getState());
+	}
+	listAllTools(server) {
+		if (server) {
+			const manager = this.servers.get(server);
+			if (!manager) return [];
+			return manager.listTools().map((tool) => ({
+				server,
+				tool
+			}));
+		}
+		const result = [];
+		for (const [name, manager] of this.servers) {
+			if (manager.getStatus() !== "connected") continue;
+			for (const tool of manager.listTools()) result.push({
+				server: name,
+				tool
+			});
+		}
+		return result;
+	}
+	findTool(serverTool) {
+		const slashIndex = serverTool.indexOf("/");
+		if (slashIndex === -1) return void 0;
+		const serverName = serverTool.slice(0, slashIndex);
+		const toolName = serverTool.slice(slashIndex + 1);
+		const manager = this.servers.get(serverName);
+		if (!manager) return void 0;
+		const tool = manager.listTools().find((t) => t.name === toolName);
+		if (!tool) return void 0;
+		return {
+			manager,
+			tool
+		};
+	}
+	grepTools(pattern) {
+		const normalized = pattern.replace(/\\([|()\{\}])/g, "$1");
+		const regex = new RegExp(normalized, "i");
+		const result = [];
+		for (const [name, manager] of this.servers) {
+			if (manager.getStatus() !== "connected") continue;
+			for (const tool of manager.listTools()) if (regex.test(`${name}/${tool.name}`) || tool.title && regex.test(tool.title) || tool.description && regex.test(tool.description)) result.push({
+				server: name,
+				tool
+			});
+		}
+		return result;
+	}
+	listAllResources(server) {
+		if (server) {
+			const manager = this.servers.get(server);
+			if (!manager) return [];
+			return manager.listResources().map((resource) => ({
+				server,
+				resource
+			}));
+		}
+		const result = [];
+		for (const [name, manager] of this.servers) {
+			if (manager.getStatus() !== "connected") continue;
+			for (const resource of manager.listResources()) result.push({
+				server: name,
+				resource
+			});
+		}
+		return result;
+	}
+	async readResource(serverName, uri) {
+		const manager = this.servers.get(serverName);
+		if (!manager) throw new Error(`Server not found: ${serverName}`);
+		return await manager.readResource(uri);
+	}
+	listAllPrompts(server) {
+		if (server) {
+			const manager = this.servers.get(server);
+			if (!manager) return [];
+			return manager.listPrompts().map((prompt) => ({
+				server,
+				prompt
+			}));
+		}
+		const result = [];
+		for (const [name, manager] of this.servers) {
+			if (manager.getStatus() !== "connected") continue;
+			for (const prompt of manager.listPrompts()) result.push({
+				server: name,
+				prompt
+			});
+		}
+		return result;
+	}
+	async getPrompt(serverName, name, args) {
+		const manager = this.servers.get(serverName);
+		if (!manager) throw new Error(`Server not found: ${serverName}`);
+		return await manager.getPrompt(name, args);
+	}
+	async complete(serverName, ref, argument) {
+		const manager = this.servers.get(serverName);
+		if (!manager) throw new Error(`Server not found: ${serverName}`);
+		return await manager.complete(ref, argument);
+	}
+	async listAllTasks(server) {
+		const result = [];
+		const managers = server ? [[server, this.servers.get(server)]].filter(([, m]) => m) : [...this.servers.entries()];
+		for (const [name, manager] of managers) {
+			if (!manager || manager.getStatus() !== "connected") continue;
+			try {
+				const taskResult = await manager.listTasks();
+				result.push({
+					server: name,
+					tasks: taskResult.tasks
+				});
+			} catch {}
+		}
+		return result;
+	}
+	async getTask(serverName, taskId) {
+		const tracked = this.trackedTasks.get(taskId);
+		if (tracked && tracked.status === "unreachable") throw new Error(`Task ${taskId} is unreachable: server "${tracked.server}" disconnected`);
+		const manager = this.servers.get(serverName);
+		if (!manager) throw new Error(`Server not found: ${serverName}`);
+		return await manager.getTask(taskId);
+	}
+	async getTaskResult(serverName, taskId) {
+		const tracked = this.trackedTasks.get(taskId);
+		if (tracked && tracked.status === "unreachable") throw new Error(`Task ${taskId} is unreachable: server "${tracked.server}" disconnected`);
+		const manager = this.servers.get(serverName);
+		if (!manager) throw new Error(`Server not found: ${serverName}`);
+		return await manager.getTaskResult(taskId);
+	}
+	async cancelTask(serverName, taskId) {
+		const tracked = this.trackedTasks.get(taskId);
+		if (tracked && tracked.status === "unreachable") throw new Error(`Task ${taskId} is unreachable: server "${tracked.server}" disconnected`);
+		const manager = this.servers.get(serverName);
+		if (!manager) throw new Error(`Server not found: ${serverName}`);
+		const result = await manager.cancelTask(taskId);
+		this.trackedTasks.delete(taskId);
+		return result;
+	}
+	async reload(newConfig) {
+		const oldNames = new Set(this.servers.keys());
+		const newNames = new Set(Object.keys(newConfig.mcpServers));
+		const added = [];
+		const removed = [];
+		const changed = [];
+		for (const name of oldNames) if (!newNames.has(name)) {
+			removed.push(name);
+			const manager = this.servers.get(name);
+			if (manager) await manager.disconnect().catch(() => {});
+			this.servers.delete(name);
+		}
+		for (const [name, serverConfig] of Object.entries(newConfig.mcpServers)) if (!oldNames.has(name)) {
+			added.push(name);
+			const manager = new ServerManager(name, serverConfig, {
+				connectTimeout: newConfig.daemon?.connectTimeout,
+				healthCheckInterval: newConfig.daemon?.healthCheckInterval,
+				maxRestartAttempts: newConfig.daemon?.maxRestartAttempts
+			});
+			manager.setHealthCallback((serverName, status, error) => {
+				this.onServerHealthChange(serverName, status, error);
+			});
+			this.servers.set(name, manager);
+			await manager.connect(newConfig.daemon?.connectTimeout).catch(() => {});
+		} else {
+			const oldState = this.servers.get(name).getState();
+			if (JSON.stringify(oldState.config) !== JSON.stringify(serverConfig)) {
+				changed.push(name);
+				await this.servers.get(name).disconnect().catch(() => {});
+				const newManager = new ServerManager(name, serverConfig, {
+					connectTimeout: newConfig.daemon?.connectTimeout,
+					healthCheckInterval: newConfig.daemon?.healthCheckInterval,
+					maxRestartAttempts: newConfig.daemon?.maxRestartAttempts
+				});
+				newManager.setHealthCallback((serverName, status, error) => {
+					this.onServerHealthChange(serverName, status, error);
+				});
+				this.servers.set(name, newManager);
+				await newManager.connect(newConfig.daemon?.connectTimeout).catch(() => {});
+			}
+		}
+		return {
+			added,
+			removed,
+			changed
+		};
+	}
+};
+async function generateTypes(tools) {
+	const toolTypes = [];
+	for (const { server, tool } of tools) {
+		const qualifiedName = escapeKey(`${server}/${tool.name}`);
+		const inputType = await schemaToType(tool.inputSchema, `${server}_${tool.name}_input`);
+		const outputType = tool.outputSchema ? await schemaToType(tool.outputSchema, `${server}_${tool.name}_output`) : "unknown";
+		const jsdoc = tool.description ? `    /** ${escapeJsdoc(tool.description)} */\n` : "";
+		toolTypes.push(`${jsdoc}    '${qualifiedName}': {\n      input: ${indent(inputType, 6)};\n      output: ${indent(outputType, 6)};\n    };`);
+	}
+	return `// Auto-generated by \`toold typegen\` – do not edit
+// Run \`toold typegen\` to regenerate
+
+declare module 'toold' {
+  interface TooldToolMap {
+${toolTypes.join("\n")}
+  }
+}
+
+export {};
+`;
+}
+async function schemaToType(schema, name) {
+	return extractTypeBody(await compile(schema, name, {
+		bannerComment: "",
+		additionalProperties: false,
+		unknownAny: true,
+		format: false
+	}));
+}
+function extractTypeBody(compiled) {
+	const match = compiled.match(/\{[\s\S]*\}/);
+	if (!match) return "Record<string, unknown>";
+	return match[0];
+}
+function escapeKey(key) {
+	return key.replace(/\\/g, "\\\\").replace(/'/g, "\\'");
+}
+function escapeJsdoc(text) {
+	return text.replace(/\*\//g, "*\\/");
+}
+function indent(text, spaces) {
+	const pad = " ".repeat(spaces);
+	return text.split("\n").join("\n" + pad);
+}
+function createDaemonServer(serverPool, config) {
+	const socketPath = getSocketPath();
+	let idleTimer;
+	let shutdownInProgress = false;
+	const activeSockets = /* @__PURE__ */ new Set();
+	let inFlightRequests = 0;
+	const idleTimeout = config.daemon?.idleTimeout ?? 3e5;
+	const requestTimeout = config.daemon?.requestTimeout ?? 6e4;
+	config.daemon?.maxTotalTimeout;
+	const shutdownTimeout = config.daemon?.shutdownTimeout ?? 1e4;
+	const startTime = Date.now();
+	const logger = getLogger();
+	function resetIdleTimer() {
+		if (idleTimer) clearTimeout(idleTimer);
+		if (idleTimeout > 0) idleTimer = setTimeout(() => {
+			logger.info("Idle timeout reached, shutting down");
+			shutdown().catch(() => {});
+		}, idleTimeout);
+	}
+	async function handleRequest(request, clientTimeout) {
+		const { method, params, id } = request;
+		switch (method) {
+			case "servers/list": return {
+				jsonrpc: "2.0",
+				id,
+				result: serverPool.listServers()
+			};
+			case "tools/list": {
+				const server = params?.server;
+				return {
+					jsonrpc: "2.0",
+					id,
+					result: serverPool.listAllTools(server)
+				};
+			}
+			case "tools/call": {
+				const p = params;
+				if (!p?.name) return {
+					jsonrpc: "2.0",
+					id,
+					error: {
+						code: -32602,
+						message: "Missing required parameter: name"
+					}
+				};
+				const found = serverPool.findTool(p.name);
+				if (!found) return {
+					jsonrpc: "2.0",
+					id,
+					error: {
+						code: -32602,
+						message: `Tool not found: ${p.name}`
+					}
+				};
+				const timeout = clientTimeout ?? p.timeout ?? requestTimeout;
+				return {
+					jsonrpc: "2.0",
+					id,
+					result: await found.manager.callTool(found.tool.name, p.arguments ?? {}, timeout)
+				};
+			}
+			case "tools/info": {
+				const p = params;
+				if (!p?.name) return {
+					jsonrpc: "2.0",
+					id,
+					error: {
+						code: -32602,
+						message: "Missing required parameter: name"
+					}
+				};
+				const found = serverPool.findTool(p.name);
+				if (!found) return {
+					jsonrpc: "2.0",
+					id,
+					error: {
+						code: -32602,
+						message: `Tool not found: ${p.name}`
+					}
+				};
+				return {
+					jsonrpc: "2.0",
+					id,
+					result: found.tool
+				};
+			}
+			case "auth/status": {
+				const server = params?.server;
+				const results = [];
+				if (server) {
+					const manager = serverPool.getServer(server);
+					if (!manager) return {
+						jsonrpc: "2.0",
+						id,
+						error: {
+							code: -32602,
+							message: `Server not found: ${server}`
+						}
+					};
+					const authStatus = manager.getAuthStatus();
+					if (authStatus) results.push({
+						server,
+						auth: authStatus
+					});
+				} else for (const state of serverPool.listServers()) {
+					const manager = serverPool.getServer(state.name);
+					if (manager) {
+						const authStatus = manager.getAuthStatus();
+						if (authStatus) results.push({
+							server: state.name,
+							auth: authStatus
+						});
+					}
+				}
+				return {
+					jsonrpc: "2.0",
+					id,
+					result: results
+				};
+			}
+			case "daemon/status": return {
+				jsonrpc: "2.0",
+				id,
+				result: {
+					pid: process.pid,
+					uptime: Date.now() - startTime,
+					serverCount: serverPool.listServers().length,
+					servers: serverPool.listServers()
+				}
+			};
+			case "tools/grep": {
+				const p = params;
+				if (!p?.pattern) return {
+					jsonrpc: "2.0",
+					id,
+					error: {
+						code: -32602,
+						message: "Missing required parameter: pattern"
+					}
+				};
+				try {
+					return {
+						jsonrpc: "2.0",
+						id,
+						result: serverPool.grepTools(p.pattern)
+					};
+				} catch (err) {
+					return {
+						jsonrpc: "2.0",
+						id,
+						error: {
+							code: -32602,
+							message: err instanceof Error ? err.message : "Invalid pattern"
+						}
+					};
+				}
+			}
+			case "resources/list": {
+				const server = params?.server;
+				return {
+					jsonrpc: "2.0",
+					id,
+					result: serverPool.listAllResources(server)
+				};
+			}
+			case "resources/read": {
+				const p = params;
+				if (!p?.server || !p?.uri) return {
+					jsonrpc: "2.0",
+					id,
+					error: {
+						code: -32602,
+						message: "Missing required parameters: server, uri"
+					}
+				};
+				return {
+					jsonrpc: "2.0",
+					id,
+					result: await serverPool.readResource(p.server, p.uri)
+				};
+			}
+			case "prompts/list": {
+				const server = params?.server;
+				return {
+					jsonrpc: "2.0",
+					id,
+					result: serverPool.listAllPrompts(server)
+				};
+			}
+			case "prompts/get": {
+				const p = params;
+				if (!p?.server || !p?.name) return {
+					jsonrpc: "2.0",
+					id,
+					error: {
+						code: -32602,
+						message: "Missing required parameters: server, name"
+					}
+				};
+				return {
+					jsonrpc: "2.0",
+					id,
+					result: await serverPool.getPrompt(p.server, p.name, p.arguments)
+				};
+			}
+			case "completions/complete": {
+				const p = params;
+				if (!p?.server || !p?.ref || !p?.argument) return {
+					jsonrpc: "2.0",
+					id,
+					error: {
+						code: -32602,
+						message: "Missing required parameters: server, ref, argument"
+					}
+				};
+				return {
+					jsonrpc: "2.0",
+					id,
+					result: await serverPool.complete(p.server, p.ref, p.argument)
+				};
+			}
+			case "tasks/list": {
+				const server = params?.server;
+				return {
+					jsonrpc: "2.0",
+					id,
+					result: await serverPool.listAllTasks(server)
+				};
+			}
+			case "tasks/get": {
+				const p = params;
+				if (!p?.server || !p?.taskId) return {
+					jsonrpc: "2.0",
+					id,
+					error: {
+						code: -32602,
+						message: "Missing required parameters: server, taskId"
+					}
+				};
+				return {
+					jsonrpc: "2.0",
+					id,
+					result: await serverPool.getTask(p.server, p.taskId)
+				};
+			}
+			case "tasks/result": {
+				const p = params;
+				if (!p?.server || !p?.taskId) return {
+					jsonrpc: "2.0",
+					id,
+					error: {
+						code: -32602,
+						message: "Missing required parameters: server, taskId"
+					}
+				};
+				return {
+					jsonrpc: "2.0",
+					id,
+					result: await serverPool.getTaskResult(p.server, p.taskId)
+				};
+			}
+			case "tasks/cancel": {
+				const p = params;
+				if (!p?.server || !p?.taskId) return {
+					jsonrpc: "2.0",
+					id,
+					error: {
+						code: -32602,
+						message: "Missing required parameters: server, taskId"
+					}
+				};
+				return {
+					jsonrpc: "2.0",
+					id,
+					result: await serverPool.cancelTask(p.server, p.taskId)
+				};
+			}
+			case "tools/call-async": {
+				const p = params;
+				if (!p?.name) return {
+					jsonrpc: "2.0",
+					id,
+					error: {
+						code: -32602,
+						message: "Missing required parameter: name"
+					}
+				};
+				const found = serverPool.findTool(p.name);
+				if (!found) return {
+					jsonrpc: "2.0",
+					id,
+					error: {
+						code: -32602,
+						message: `Tool not found: ${p.name}`
+					}
+				};
+				const taskHandle = await found.manager.callToolWithTask(found.tool.name, p.arguments ?? {});
+				serverPool.trackTask(taskHandle.taskId, found.manager.name);
+				return {
+					jsonrpc: "2.0",
+					id,
+					result: {
+						...taskHandle,
+						server: found.manager.name
+					}
+				};
+			}
+			case "config/reload": {
+				const newConfig = loadConfig(params?.configPath);
+				const changes = await serverPool.reload(newConfig);
+				logger.info(`Config reloaded: added=${changes.added.length}, removed=${changes.removed.length}, changed=${changes.changed.length}`);
+				return {
+					jsonrpc: "2.0",
+					id,
+					result: changes
+				};
+			}
+			case "daemon/stop":
+				setImmediate(() => {
+					shutdown().catch(() => {});
+				});
+				return {
+					jsonrpc: "2.0",
+					id,
+					result: { ok: true }
+				};
+			default: return {
+				jsonrpc: "2.0",
+				id,
+				error: {
+					code: -32601,
+					message: `Method not found: ${method}`
+				}
+			};
+		}
+	}
+	const server = net.createServer((socket) => {
+		if (shutdownInProgress) {
+			socket.destroy();
+			return;
+		}
+		activeSockets.add(socket);
+		let buffer = "";
+		socket.on("close", () => {
+			activeSockets.delete(socket);
+		});
+		socket.on("data", (data) => {
+			buffer += data.toString();
+			const lines = buffer.split("\n");
+			buffer = lines.pop() ?? "";
+			for (const line of lines) {
+				const trimmed = line.trim();
+				if (!trimmed) continue;
+				resetIdleTimer();
+				let request;
+				try {
+					request = JSON.parse(trimmed);
+				} catch {
+					socket.write(JSON.stringify({
+						jsonrpc: "2.0",
+						id: null,
+						error: {
+							code: -32700,
+							message: "Parse error"
+						}
+					}) + "\n");
+					continue;
+				}
+				inFlightRequests++;
+				const clientTimeout = request.params?.timeout;
+				handleRequest(request, clientTimeout).then((response) => {
+					if (!socket.destroyed) socket.write(JSON.stringify(response) + "\n");
+				}).catch((err) => {
+					const errorResponse = {
+						jsonrpc: "2.0",
+						id: request.id,
+						error: {
+							code: -32603,
+							message: err instanceof Error ? err.message : "Internal error"
+						}
+					};
+					if (!socket.destroyed) socket.write(JSON.stringify(errorResponse) + "\n");
+				}).finally(() => {
+					inFlightRequests--;
+				});
+			}
+		});
+		socket.on("error", () => {
+			activeSockets.delete(socket);
+		});
+	});
+	async function shutdown() {
+		if (shutdownInProgress) return;
+		shutdownInProgress = true;
+		logger.info("Shutting down daemon...");
+		if (idleTimer) clearTimeout(idleTimer);
+		server.close();
+		if (inFlightRequests > 0) {
+			logger.info(`Waiting for ${inFlightRequests} in-flight requests to complete...`);
+			await Promise.race([new Promise((resolve) => {
+				const check = setInterval(() => {
+					if (inFlightRequests <= 0) {
+						clearInterval(check);
+						resolve();
+					}
+				}, 100);
+			}), new Promise((resolve) => setTimeout(resolve, shutdownTimeout))]);
+			if (inFlightRequests > 0) logger.warn(`Forcing shutdown with ${inFlightRequests} requests still in flight`);
+		}
+		for (const socket of activeSockets) socket.destroy();
+		activeSockets.clear();
+		await serverPool.disconnectAll();
+		logger.info("All servers disconnected");
+		try {
+			fs.unlinkSync(socketPath);
+		} catch {}
+		try {
+			const { getPidPath } = await Promise.resolve().then(() => paths_exports);
+			fs.unlinkSync(getPidPath());
+		} catch {}
+		logger.info("Daemon shutdown complete");
+		process.exit(0);
+	}
+	try {
+		fs.unlinkSync(socketPath);
+	} catch {}
+	server.listen(socketPath);
+	resetIdleTimer();
+	return {
+		server,
+		resetIdleTimer,
+		shutdown,
+		handleRequest
+	};
+}
+const ALLOWED_ORIGIN_RE = /^https?:\/\/(localhost|127\.0\.0\.1)(:\d+)?$/;
+function isOriginAllowed(origin) {
+	return ALLOWED_ORIGIN_RE.test(origin);
+}
+function createHttpListener(handleRequest, config) {
+	const logger = getLogger();
+	const httpServer = http.createServer((req, res) => {
+		const origin = req.headers.origin;
+		if (origin && !isOriginAllowed(origin)) {
+			res.writeHead(403, { "Content-Type": "application/json" });
+			res.end(JSON.stringify({
+				jsonrpc: "2.0",
+				id: null,
+				error: {
+					code: -32600,
+					message: "Forbidden origin"
+				}
+			}));
+			return;
+		}
+		if (req.method !== "POST") {
+			res.writeHead(405, { "Content-Type": "application/json" });
+			res.end(JSON.stringify({
+				jsonrpc: "2.0",
+				id: null,
+				error: {
+					code: -32600,
+					message: "Method not allowed"
+				}
+			}));
+			return;
+		}
+		let body = "";
+		req.on("data", (chunk) => {
+			body += chunk.toString();
+		});
+		req.on("end", () => {
+			let request;
+			try {
+				request = JSON.parse(body);
+			} catch {
+				res.writeHead(400, { "Content-Type": "application/json" });
+				res.end(JSON.stringify({
+					jsonrpc: "2.0",
+					id: null,
+					error: {
+						code: -32700,
+						message: "Parse error"
+					}
+				}));
+				return;
+			}
+			const clientTimeout = request.params?.timeout;
+			handleRequest(request, clientTimeout).then((response) => {
+				res.writeHead(200, { "Content-Type": "application/json" });
+				res.end(JSON.stringify(response));
+			}).catch((err) => {
+				const errorResponse = {
+					jsonrpc: "2.0",
+					id: request.id,
+					error: {
+						code: -32603,
+						message: err instanceof Error ? err.message : "Internal error"
+					}
+				};
+				res.writeHead(200, { "Content-Type": "application/json" });
+				res.end(JSON.stringify(errorResponse));
+			});
+		});
+	});
+	httpServer.listen(config.port, config.host, () => {
+		logger.info(`HTTP listener on ${config.host}:${config.port}`);
+	});
+	function shutdown() {
+		return new Promise((resolve) => {
+			httpServer.close(() => resolve());
+		});
+	}
+	return {
+		httpServer,
+		shutdown
+	};
+}
+async function runAutoTypegen(serverPool, logger) {
+	try {
+		const require = createRequire(path.resolve("package.json"));
+		const tooldPkgDir = path.dirname(require.resolve("toold/package.json"));
+		const outputPath = path.join(tooldPkgDir, "toold.generated.d.ts");
+		const tools = serverPool.listAllTools();
+		if (tools.length === 0) {
+			logger.debug("No tools available, skipping typegen");
+			return;
+		}
+		const content = await generateTypes(tools);
+		fs.writeFileSync(outputPath, content, "utf-8");
+		logger.info(`Auto-generated ${tools.length} tool types → ${outputPath}`);
+	} catch {
+		logger.debug("Skipping auto-typegen (toold not resolvable as a dependency)");
+	}
+}
+async function startDaemon(configPath) {
+	const config = loadConfig(configPath);
+	ensureTooldDir();
+	const isForeground = !!process.send;
+	const logger = initLogger({
+		level: config.daemon?.logLevel ?? "info",
+		stderr: isForeground
+	});
+	logger.info("Starting daemon...");
+	const serverPool = new ServerPool();
+	await serverPool.connectAll(config);
+	const connectedCount = serverPool.listServers().filter((s) => s.status === "connected").length;
+	const totalCount = serverPool.listServers().length;
+	logger.info(`Connected ${connectedCount}/${totalCount} servers`);
+	await runAutoTypegen(serverPool, logger);
+	const { server, shutdown, handleRequest } = createDaemonServer(serverPool, config);
+	let httpShutdown;
+	const httpConfig = config.daemon?.http;
+	if (httpConfig?.enabled) {
+		const { shutdown: httpStop } = createHttpListener(handleRequest, {
+			port: httpConfig.port ?? 3100,
+			host: httpConfig.host ?? "127.0.0.1"
+		});
+		httpShutdown = httpStop;
+	}
+	server.on("listening", () => {
+		fs.writeFileSync(getPidPath(), String(process.pid));
+		logger.info(`Daemon listening (PID: ${process.pid})`);
+		if (process.send) process.send("ready");
+	});
+	async function fullShutdown() {
+		if (httpShutdown) await httpShutdown();
+		await shutdown();
+	}
+	process.on("SIGTERM", () => {
+		logger.info("Received SIGTERM");
+		fullShutdown().catch(() => {
+			process.exit(1);
+		});
+	});
+	process.on("SIGINT", () => {
+		logger.info("Received SIGINT");
+		fullShutdown().catch(() => {
+			process.exit(1);
+		});
+	});
+	process.on("uncaughtException", (err) => {
+		logger.error(`Uncaught exception: ${err.message}`);
+		fullShutdown().catch(() => {
+			process.exit(1);
+		});
+	});
+	process.on("unhandledRejection", (reason) => {
+		const msg = reason instanceof Error ? reason.message : String(reason);
+		logger.error(`Unhandled rejection: ${msg}`);
+	});
+}
+function getLockPath() {
+	return path.join(getTooldDir(), "toold.lock");
+}
+function getDaemonPid() {
+	try {
+		const content = fs.readFileSync(getPidPath(), "utf-8").trim();
+		const pid = parseInt(content, 10);
+		return Number.isFinite(pid) && pid > 0 ? pid : null;
+	} catch {
+		return null;
+	}
+}
+function isProcessAlive(pid) {
+	try {
+		process.kill(pid, 0);
+		return true;
+	} catch {
+		return false;
+	}
+}
+function isTooldProcess(pid) {
+	try {
+		const cmdline = fs.readFileSync(`/proc/${pid}/cmdline`, "utf-8");
+		return cmdline.includes("toold") || cmdline.includes("node");
+	} catch {
+		return isProcessAlive(pid);
+	}
+}
+function tryConnectSocket(socketPath) {
+	return new Promise((resolve) => {
+		const socket = net.createConnection(socketPath);
+		const timeout = setTimeout(() => {
+			socket.destroy();
+			resolve(false);
+		}, 2e3);
+		socket.on("connect", () => {
+			clearTimeout(timeout);
+			socket.destroy();
+			resolve(true);
+		});
+		socket.on("error", () => {
+			clearTimeout(timeout);
+			resolve(false);
+		});
+	});
+}
+function acquireLock() {
+	const lockPath = getLockPath();
+	try {
+		ensureTooldDir();
+		fs.writeFileSync(lockPath, String(process.pid), { flag: "wx" });
+		return true;
+	} catch (err) {
+		if (err.code === "EEXIST") try {
+			const lockPid = parseInt(fs.readFileSync(lockPath, "utf-8").trim(), 10);
+			if (!Number.isFinite(lockPid) || !isProcessAlive(lockPid) || !isTooldProcess(lockPid)) {
+				fs.unlinkSync(lockPath);
+				try {
+					fs.writeFileSync(lockPath, String(process.pid), { flag: "wx" });
+					return true;
+				} catch {
+					return false;
+				}
+			}
+		} catch {
+			try {
+				fs.unlinkSync(lockPath);
+			} catch {}
+		}
+		return false;
+	}
+}
+function releaseLock() {
+	try {
+		fs.unlinkSync(getLockPath());
+	} catch {}
+}
+async function isDaemonRunning() {
+	const pid = getDaemonPid();
+	if (pid === null) return false;
+	if (!isProcessAlive(pid)) return false;
+	if (!isTooldProcess(pid)) return false;
+	return tryConnectSocket(getSocketPath());
+}
+async function cleanupStaleFiles() {
+	const pidPath = getPidPath();
+	const socketPath = getSocketPath();
+	const pid = getDaemonPid();
+	if (pid !== null && !isProcessAlive(pid)) {
+		try {
+			fs.unlinkSync(pidPath);
+		} catch {}
+		try {
+			fs.unlinkSync(socketPath);
+		} catch {}
+		releaseLock();
+		return;
+	}
+	if (pid !== null && isProcessAlive(pid) && !isTooldProcess(pid)) {
+		try {
+			fs.unlinkSync(pidPath);
+		} catch {}
+		try {
+			fs.unlinkSync(socketPath);
+		} catch {}
+		releaseLock();
+		return;
+	}
+	if (pid === null) {
+		try {
+			fs.unlinkSync(socketPath);
+		} catch {}
+		releaseLock();
+	}
+}
+async function daemonize(configPath) {
+	if (!acquireLock()) {
+		for (let i = 0; i < 10; i++) {
+			await new Promise((resolve) => setTimeout(resolve, 1e3));
+			if (await isDaemonRunning()) return;
+		}
+		throw new Error("Timed out waiting for another process to start the daemon.");
+	}
+	try {
+		const cliEntry = process.argv[1];
+		const args = ["--daemon"];
+		if (configPath) args.push("--config", configPath);
+		await new Promise((resolve, reject) => {
+			const child = fork(cliEntry, args, {
+				detached: true,
+				stdio: [
+					"ignore",
+					"ignore",
+					"ignore",
+					"ipc"
+				]
+			});
+			const timeout = setTimeout(() => {
+				child.unref();
+				child.disconnect?.();
+				reject(/* @__PURE__ */ new Error("Daemon failed to start: timeout waiting for ready signal"));
+			}, 1e4);
+			child.on("message", (msg) => {
+				if (msg === "ready") {
+					clearTimeout(timeout);
+					child.unref();
+					child.disconnect?.();
+					resolve();
+				}
+			});
+			child.on("error", (err) => {
+				clearTimeout(timeout);
+				reject(/* @__PURE__ */ new Error(`Daemon failed to start: ${err.message}`));
+			});
+			child.on("exit", (code) => {
+				clearTimeout(timeout);
+				if (code !== 0) reject(/* @__PURE__ */ new Error(`Daemon exited with code ${code}`));
+			});
+		});
+	} finally {
+		releaseLock();
+	}
+}
+var TooldError = class extends Error {
+	code;
+	data;
+	constructor(code, message, data) {
+		super(message);
+		this.name = "TooldError";
+		this.code = code;
+		this.data = data;
+	}
+};
+async function waitForSocket(socketPath, retries) {
+	for (const delay of retries) {
+		await new Promise((resolve) => setTimeout(resolve, delay));
+		if (await new Promise((resolve) => {
+			const sock = net.createConnection(socketPath);
+			const timeout = setTimeout(() => {
+				sock.destroy();
+				resolve(false);
+			}, 2e3);
+			sock.on("connect", () => {
+				clearTimeout(timeout);
+				sock.destroy();
+				resolve(true);
+			});
+			sock.on("error", () => {
+				clearTimeout(timeout);
+				resolve(false);
+			});
+		})) return;
+	}
+	throw new Error("Daemon started but socket is not responding");
+}
+async function ensureDaemon(configPath) {
+	if (await isDaemonRunning()) return;
+	await cleanupStaleFiles();
+	await daemonize(configPath);
+	await waitForSocket(getSocketPath(), [
+		100,
+		200,
+		400
+	]);
+}
+async function sendRequest(method, params) {
+	const socketPath = getSocketPath();
+	return new Promise((resolve, reject) => {
+		const socket = net.createConnection(socketPath);
+		let buffer = "";
+		socket.on("error", (err) => {
+			if (err.code === "ENOENT") reject(/* @__PURE__ */ new Error("Daemon is not running. Run `toold status` to check."));
+			else if (err.code === "ECONNREFUSED") reject(/* @__PURE__ */ new Error("Daemon may have crashed. Try running a command to auto-restart it."));
+			else reject(err);
+		});
+		socket.on("connect", () => {
+			const request = {
+				jsonrpc: "2.0",
+				id: 1,
+				method,
+				...params ? { params } : {}
+			};
+			socket.write(JSON.stringify(request) + "\n");
+		});
+		socket.on("data", (data) => {
+			buffer += data.toString();
+			const newlineIndex = buffer.indexOf("\n");
+			if (newlineIndex === -1) return;
+			const line = buffer.slice(0, newlineIndex).trim();
+			socket.destroy();
+			try {
+				const response = JSON.parse(line);
+				if (response.error) reject(new TooldError(response.error.code, response.error.message, response.error.data));
+				else resolve(response.result);
+			} catch {
+				reject(/* @__PURE__ */ new Error("Invalid response from daemon"));
+			}
+		});
+	});
+}
+function padRight(str, len) {
+	return str.length >= len ? str : str + " ".repeat(len - str.length);
+}
+function truncate(str, maxLen) {
+	if (str.length <= maxLen) return str;
+	return str.slice(0, maxLen - 1) + "…";
+}
+function formatUptime(ms) {
+	const seconds = Math.floor(ms / 1e3);
+	if (seconds < 60) return `${seconds}s`;
+	const minutes = Math.floor(seconds / 60);
+	if (minutes < 60) return `${minutes}m ${seconds % 60}s`;
+	return `${Math.floor(minutes / 60)}h ${minutes % 60}m`;
+}
+function formatServers(servers) {
+	if (servers.length === 0) return "No servers configured.";
+	return formatTable([
+		"Name",
+		"Title",
+		"Status",
+		"Protocol"
+	], servers.map((s) => [
+		s.name,
+		s.serverInfo?.title ?? "—",
+		s.status,
+		s.protocolVersion ?? "—"
+	]));
+}
+function formatTools(tools) {
+	if (tools.length === 0) return "No tools available.";
+	return formatTable([
+		"Tool",
+		"Title",
+		"Description",
+		"Hints"
+	], tools.map(({ server, tool }) => {
+		const hints = [];
+		if (tool.annotations?.readOnlyHint) hints.push("[read-only]");
+		if (tool.annotations?.destructiveHint) hints.push("[destructive]");
+		if (tool.annotations?.idempotentHint) hints.push("[idempotent]");
+		return [
+			`${server}/${tool.name}`,
+			tool.title ?? "—",
+			truncate(tool.description ?? "", 60),
+			hints.join(" ")
+		];
+	}));
+}
+function formatToolInfo(server, tool) {
+	const lines = [];
+	lines.push(`${server}/${tool.name}`);
+	lines.push(`Title: ${tool.title ?? "—"}`);
+	lines.push(`Description: ${tool.description ?? "—"}`);
+	lines.push("");
+	lines.push("Input Schema:");
+	lines.push("  " + JSON.stringify(tool.inputSchema, null, 2).split("\n").join("\n  "));
+	if (tool.outputSchema) {
+		lines.push("");
+		lines.push("Output Schema:");
+		lines.push("  " + JSON.stringify(tool.outputSchema, null, 2).split("\n").join("\n  "));
+	}
+	const annotations = tool.annotations;
+	if (annotations) {
+		const entries = Object.entries(annotations).filter(([, v]) => v);
+		if (entries.length > 0) {
+			lines.push("");
+			lines.push("Annotations:");
+			for (const [key, value] of entries) lines.push(`  ${key}: ${value}`);
+		}
+	}
+	if (tool.execution?.taskSupport) {
+		lines.push("");
+		lines.push(`Task Support: ${tool.execution.taskSupport}`);
+	}
+	return lines.join("\n");
+}
+function formatCallResult(result) {
+	const parts = [];
+	if (result.isError) parts.push("Error:");
+	for (const block of result.content) switch (block.type) {
+		case "text":
+			parts.push(block.text ?? "");
+			break;
+		case "image":
+			parts.push(`[Image: ${block.mimeType}]`);
+			break;
+		case "audio":
+			parts.push(`[Audio: ${block.mimeType}]`);
+			break;
+		case "resource_link":
+			parts.push(`Resource: ${block.name ?? block.uri} (${block.uri})`);
+			break;
+		case "resource":
+			if (block.resource?.text !== void 0) parts.push(block.resource.text);
+			else parts.push(`[Binary: ${block.resource?.mimeType ?? "unknown"}]`);
+			break;
+		default: parts.push(`[${block.type}]`);
+	}
+	if (result.structuredContent) {
+		parts.push("");
+		parts.push("Structured Output:");
+		parts.push("  " + JSON.stringify(result.structuredContent, null, 2).split("\n").join("\n  "));
+	}
+	return parts.join("\n");
+}
+function formatStatus(status) {
+	const lines = [];
+	lines.push(`PID: ${status.pid}`);
+	lines.push(`Uptime: ${formatUptime(status.uptime)}`);
+	lines.push(`Servers: ${status.serverCount}`);
+	if (status.servers.length > 0) {
+		lines.push("");
+		for (const server of status.servers) {
+			const title = server.serverInfo?.title ? ` (${server.serverInfo.title})` : "";
+			lines.push(`  ${server.name}${title}: ${server.status}`);
+			if (server.capabilities) {
+				const caps = Object.keys(server.capabilities).join(", ");
+				if (caps) lines.push(`    capabilities: ${caps}`);
+			}
+		}
+	}
+	return lines.join("\n");
+}
+function formatResources(resources) {
+	if (resources.length === 0) return "No resources available.";
+	return formatTable([
+		"Resource",
+		"Title",
+		"MIME Type",
+		"Description"
+	], resources.map(({ server, resource }) => [
+		`${server}/${resource.name}`,
+		resource.title ?? "—",
+		resource.mimeType ?? "—",
+		truncate(resource.description ?? "", 50)
+	]));
+}
+function formatReadResource(result) {
+	const parts = [];
+	for (const content of result.contents) if (content.text !== void 0) parts.push(content.text);
+	else if (content.blob) parts.push(`[Binary: ${content.mimeType ?? "unknown"}, ${content.blob.length} bytes]`);
+	return parts.join("\n");
+}
+function formatPrompts(prompts) {
+	if (prompts.length === 0) return "No prompts available.";
+	return formatTable([
+		"Prompt",
+		"Title",
+		"Description",
+		"Args"
+	], prompts.map(({ server, prompt }) => [
+		`${server}/${prompt.name}`,
+		prompt.title ?? "—",
+		truncate(prompt.description ?? "", 50),
+		prompt.arguments ? String(prompt.arguments.length) : "0"
+	]));
+}
+function formatPromptMessages(result) {
+	const lines = [];
+	if (result.description) {
+		lines.push(result.description);
+		lines.push("");
+	}
+	for (const msg of result.messages) {
+		lines.push(`[${msg.role}]`);
+		const contents = Array.isArray(msg.content) ? msg.content : [msg.content];
+		for (const block of contents) switch (block.type) {
+			case "text":
+				lines.push(block.text ?? "");
+				break;
+			case "image":
+				lines.push(`[Image: ${block.mimeType}]`);
+				break;
+			case "audio":
+				lines.push(`[Audio: ${block.mimeType}]`);
+				break;
+			case "resource":
+				lines.push(`[Resource]`);
+				break;
+			default: lines.push(`[${block.type}]`);
+		}
+		lines.push("");
+	}
+	return lines.join("\n").trimEnd();
+}
+function formatCompletions(result) {
+	if (result.completion.values.length === 0) return "No completions.";
+	const lines = result.completion.values.map((v) => `  ${v}`);
+	if (result.completion.hasMore) lines.push(`  ... (${result.completion.total ?? "more"} total)`);
+	return lines.join("\n");
+}
+function formatTasks(serverTasks) {
+	const allTasks = [];
+	for (const { server, tasks } of serverTasks) for (const task of tasks) allTasks.push({
+		server,
+		task
+	});
+	if (allTasks.length === 0) return "No active tasks.";
+	return formatTable([
+		"Task ID",
+		"Status",
+		"Server",
+		"Message"
+	], allTasks.map(({ server, task }) => [
+		String(task.taskId ?? ""),
+		String(task.status ?? ""),
+		server,
+		truncate(String(task.statusMessage ?? ""), 40)
+	]));
+}
+function formatTask(task) {
+	const lines = [];
+	lines.push(`Task ID: ${task.taskId}`);
+	lines.push(`Status: ${task.status}`);
+	if (task.statusMessage) lines.push(`Message: ${task.statusMessage}`);
+	if (task.createdAt) lines.push(`Created: ${task.createdAt}`);
+	if (task.lastUpdatedAt) lines.push(`Updated: ${task.lastUpdatedAt}`);
+	return lines.join("\n");
+}
+function formatReload(result) {
+	const lines = [];
+	if (result.added.length > 0) lines.push(`Added: ${result.added.join(", ")}`);
+	if (result.removed.length > 0) lines.push(`Removed: ${result.removed.join(", ")}`);
+	if (result.changed.length > 0) lines.push(`Changed: ${result.changed.join(", ")}`);
+	if (lines.length === 0) return "No changes detected.";
+	return lines.join("\n");
+}
+function formatInit(result) {
+	const lines = [];
+	if (result.dryRun) lines.push("[dry run] No files will be modified.\n");
+	lines.push("Discovered MCP servers:\n");
+	const discHeaders = [
+		"Agent",
+		"Scope",
+		"Config",
+		"Servers"
+	];
+	const discRows = result.discovered.map((d) => [
+		d.agent,
+		d.scope,
+		d.path,
+		String(d.serverCount)
+	]);
+	lines.push(formatTable(discHeaders, discRows));
+	if (result.imported.length > 0) {
+		lines.push("");
+		lines.push(`Imported ${result.imported.length} server(s) into ${result.tooldConfigPath}:`);
+		lines.push(`  ${result.imported.join(", ")}`);
+	}
+	if (result.skipped.length > 0) {
+		lines.push("");
+		lines.push(`Skipped ${result.skipped.length} (already existed):`);
+		lines.push(`  ${result.skipped.join(", ")}`);
+	}
+	if (result.conflicts.length > 0) {
+		lines.push("");
+		lines.push("Conflicts resolved:");
+		for (const c of result.conflicts) {
+			const others = c.agents.filter((a) => a !== c.chosenAgent);
+			const alsoIn = others.length > 0 ? ` (also in: ${others.join(", ")})` : "";
+			lines.push(`  ${c.name} \u2014 kept config from ${c.chosenAgent}${alsoIn}`);
+		}
+	}
+	if (result.warnings.length > 0) {
+		lines.push("");
+		lines.push("Warnings:");
+		for (const w of result.warnings) lines.push(`  ${w}`);
+	}
+	if (result.modifiedFiles.length > 0) {
+		lines.push("");
+		lines.push("Modified files:");
+		for (const f of result.modifiedFiles) lines.push(`  ${f} (backed up to ${f}.bak)`);
+	}
+	if (result.imported.length === 0 && result.skipped.length > 0) {
+		lines.push("");
+		lines.push("All discovered servers already exist in toold config. Nothing to do.");
+	}
+	return lines.join("\n");
+}
+function formatMcpServer(name, config, scope) {
+	const lines = [];
+	lines.push(`Name: ${name}`);
+	if (scope) lines.push(`Scope: ${scope}`);
+	if (isStdioConfig(config)) {
+		lines.push(`Transport: stdio`);
+		lines.push(`Command: ${config.command}`);
+		if (config.args && config.args.length > 0) lines.push(`Args: ${config.args.join(" ")}`);
+		if (config.env && Object.keys(config.env).length > 0) {
+			lines.push("Env:");
+			for (const [key, value] of Object.entries(config.env)) lines.push(`  ${key}=${value}`);
+		}
+		if (config.cwd) lines.push(`Cwd: ${config.cwd}`);
+	} else if (isHttpConfig(config)) {
+		lines.push(`Transport: ${config.transport ?? "streamable-http"}`);
+		lines.push(`URL: ${config.url}`);
+		if (config.headers && Object.keys(config.headers).length > 0) {
+			lines.push("Headers:");
+			for (const [key, value] of Object.entries(config.headers)) lines.push(`  ${key}: ${value}`);
+		}
+		if (config.auth) {
+			lines.push(`Auth: ${config.auth.type}`);
+			if (config.auth.clientId) lines.push(`  Client ID: ${config.auth.clientId}`);
+			if (config.auth.scope) lines.push(`  Scope: ${config.auth.scope}`);
+			if (config.auth.type === "authorization_code" && config.auth.callbackPort) lines.push(`  Callback Port: ${config.auth.callbackPort}`);
+		}
+	}
+	return lines.join("\n");
+}
+function formatMcpServerList(servers) {
+	if (servers.length === 0) return "No MCP servers configured.";
+	return formatTable([
+		"Name",
+		"Type",
+		"Command/URL",
+		"Scope",
+		"Auth"
+	], servers.map(({ name, config, scope }) => {
+		if (isStdioConfig(config)) return [
+			name,
+			"stdio",
+			truncate(config.args ? `${config.command} ${config.args.join(" ")}` : config.command, 50),
+			scope,
+			"—"
+		];
+		if (isHttpConfig(config)) {
+			const transport = config.transport ?? "http";
+			const auth = config.auth ? config.auth.type : "—";
+			return [
+				name,
+				transport,
+				truncate(config.url, 50),
+				scope,
+				auth
+			];
+		}
+		return [
+			name,
+			"?",
+			"—",
+			scope,
+			"—"
+		];
+	}));
+}
+function formatJson(data) {
+	return JSON.stringify(data, null, 2);
+}
+function formatTable(headers, rows) {
+	const widths = headers.map((h, i) => Math.max(h.length, ...rows.map((r) => (r[i] ?? "").length)));
+	return [
+		headers.map((h, i) => padRight(h, widths[i])).join("  "),
+		widths.map((w) => "─".repeat(w)).join("  "),
+		...rows.map((row) => row.map((cell, i) => padRight(cell, widths[i])).join("  "))
+	].join("\n");
+}
+const serversCommand = new Command("servers").description("List connected MCP servers and their connection status").option("--json", "Output as JSON").action(async (opts) => {
+	const configPath = serversCommand.parent?.opts().config;
+	await ensureDaemon(configPath);
+	const result = await sendRequest("servers/list");
+	console.log(opts.json ? formatJson(result) : formatServers(result));
+});
+const toolsCommand = new Command("tools").description("List all available tools, optionally filtered by server name").argument("[server]", "Filter by server name").option("--json", "Output as JSON").action(async (server, opts) => {
+	const configPath = toolsCommand.parent?.opts().config;
+	await ensureDaemon(configPath);
+	const result = await sendRequest("tools/list", server ? { server } : void 0);
+	console.log(opts.json ? formatJson(result) : formatTools(result));
+});
+const infoCommand = new Command("info").description("Show input schema and description for a specific tool").argument("<server/tool>", "Tool identifier (e.g. myserver/mytool)").option("--json", "Output as JSON").action(async (serverTool, opts) => {
+	const configPath = infoCommand.parent?.opts().config;
+	await ensureDaemon(configPath);
+	const result = await sendRequest("tools/info", { name: serverTool });
+	if (opts.json) console.log(formatJson(result));
+	else {
+		const slashIndex = serverTool.indexOf("/");
+		const server = serverTool.slice(0, slashIndex);
+		console.log(formatToolInfo(server, result));
+	}
+});
+function readStdin() {
+	return new Promise((resolve, reject) => {
+		let data = "";
+		process.stdin.setEncoding("utf-8");
+		process.stdin.on("data", (chunk) => {
+			data += chunk;
+		});
+		process.stdin.on("end", () => resolve(data));
+		process.stdin.on("error", reject);
+	});
+}
+const callCommand = new Command("call").description("Execute a tool with JSON arguments (use - for stdin, --async for background)").argument("<server/tool>", "Tool identifier (e.g. myserver/mytool)").argument("[json]", "JSON arguments (use - for stdin)").option("--timeout <ms>", "Request timeout in milliseconds").option("--async", "Use task-based execution (return task handle immediately)").option("--json", "Output as JSON").action(async (serverTool, jsonArgs, opts) => {
+	const configPath = callCommand.parent?.opts().config;
+	await ensureDaemon(configPath);
+	let parsedArgs = {};
+	if (jsonArgs === "-") try {
+		const stdinData = await readStdin();
+		parsedArgs = JSON.parse(stdinData);
+	} catch {
+		console.error("Invalid JSON from stdin");
+		process.exit(1);
+	}
+	else if (jsonArgs) try {
+		parsedArgs = JSON.parse(jsonArgs);
+	} catch {
+		console.error("Invalid JSON arguments");
+		process.exit(1);
+	}
+	if (opts.async) {
+		const taskResult = await sendRequest("tools/call-async", {
+			name: serverTool,
+			arguments: parsedArgs
+		});
+		if (opts.json) console.log(formatJson(taskResult));
+		else console.log(`Task created: ${taskResult.taskId} (status: ${taskResult.status})`);
+		return;
+	}
+	const params = {
+		name: serverTool,
+		arguments: parsedArgs
+	};
+	if (opts.timeout) params.timeout = parseInt(opts.timeout, 10);
+	const result = await sendRequest("tools/call", params);
+	console.log(opts.json ? formatJson(result) : formatCallResult(result));
+});
+const grepCommand = new Command("grep").description("Search tools by regex pattern across names, titles, and descriptions").argument("<pattern>", "Regex pattern to search").option("--json", "Output as JSON").action(async (pattern, opts) => {
+	const configPath = grepCommand.parent?.opts().config;
+	await ensureDaemon(configPath);
+	const result = await sendRequest("tools/grep", { pattern });
+	console.log(opts.json ? formatJson(result) : formatTools(result));
+});
+const resourcesCommand = new Command("resources").description("List available resources, optionally filtered by server name").argument("[server]", "Filter by server name").option("--json", "Output as JSON").action(async (server, opts) => {
+	const configPath = resourcesCommand.parent?.opts().config;
+	await ensureDaemon(configPath);
+	const result = await sendRequest("resources/list", server ? { server } : void 0);
+	console.log(opts.json ? formatJson(result) : formatResources(result));
+});
+const readCommand = new Command("read").description("Fetch and display the contents of a resource by server/resource").argument("<server/resource>", "Resource identifier (e.g. myserver/myresource)").argument("[uri]", "Resource URI (optional, uses resource name as URI if not provided)").option("--json", "Output as JSON").action(async (serverResource, uri, opts) => {
+	const configPath = readCommand.parent?.opts().config;
+	await ensureDaemon(configPath);
+	const slashIndex = serverResource.indexOf("/");
+	if (slashIndex === -1) {
+		console.error("Invalid format. Use: server/resource");
+		process.exit(1);
+	}
+	const result = await sendRequest("resources/read", {
+		server: serverResource.slice(0, slashIndex),
+		uri: uri ?? serverResource.slice(slashIndex + 1)
+	});
+	console.log(opts.json ? formatJson(result) : formatReadResource(result));
+});
+function getExplicitConfig$1(cmd) {
+	return cmd.parent?.parent?.opts().config;
+}
+const daemonCommand = new Command("daemon").description("Start, stop, reload, or check status of the toold background daemon").enablePositionalOptions();
+daemonCommand.command("start").description("Start the daemon process in the background").option("--json", "Output as JSON").action(async (opts) => {
+	const configPath = getExplicitConfig$1(daemonCommand);
+	if (await isDaemonRunning()) {
+		if (opts.json) console.log(formatJson({ status: "already_running" }));
+		else console.log("Daemon is already running");
+		return;
+	}
+	await cleanupStaleFiles();
+	await daemonize(configPath);
+	const socketPath = getSocketPath();
+	for (const delay of [
+		100,
+		200,
+		400
+	]) {
+		await new Promise((resolve) => setTimeout(resolve, delay));
+		if (await new Promise((resolve) => {
+			const sock = net.createConnection(socketPath);
+			const timeout = setTimeout(() => {
+				sock.destroy();
+				resolve(false);
+			}, 2e3);
+			sock.on("connect", () => {
+				clearTimeout(timeout);
+				sock.destroy();
+				resolve(true);
+			});
+			sock.on("error", () => {
+				clearTimeout(timeout);
+				resolve(false);
+			});
+		})) {
+			if (opts.json) console.log(formatJson({ status: "started" }));
+			else console.log("Daemon started");
+			return;
+		}
+	}
+	if (opts.json) console.log(formatJson({
+		status: "started",
+		warning: "socket not yet responding"
+	}));
+	else console.log("Daemon started (socket not yet responding)");
+});
+daemonCommand.command("stop").description("Stop the running daemon process").action(async () => {
+	try {
+		await sendRequest("daemon/stop");
+		console.log("Daemon stopped");
+	} catch {
+		console.log("Daemon is not running");
+	}
+});
+daemonCommand.command("reload").description("Reload config and reconnect changed servers without restarting").option("--json", "Output as JSON").action(async (opts) => {
+	const configPath = getExplicitConfig$1(daemonCommand);
+	await ensureDaemon(configPath);
+	const result = await sendRequest("config/reload", { configPath });
+	console.log(opts.json ? formatJson(result) : formatReload(result));
+});
+daemonCommand.command("status").description("Show daemon status including uptime and connected servers").option("--json", "Output as JSON").action(async (opts) => {
+	if (!await isDaemonRunning()) {
+		console.log("Daemon is not running");
+		return;
+	}
+	const result = await sendRequest("daemon/status");
+	console.log(opts.json ? formatJson(result) : formatStatus(result));
+});
+const promptsCommand = new Command("prompts").description("List available prompt templates, optionally filtered by server name").argument("[server]", "Filter by server name").option("--json", "Output as JSON").action(async (server, opts) => {
+	const configPath = promptsCommand.parent?.opts().config;
+	await ensureDaemon(configPath);
+	const result = await sendRequest("prompts/list", server ? { server } : void 0);
+	console.log(opts.json ? formatJson(result) : formatPrompts(result));
+});
+const promptCommand = new Command("prompt").description("Render a prompt template with optional JSON arguments").argument("<server/prompt>", "Prompt identifier (e.g. myserver/myprompt)").argument("[args-json]", "JSON arguments").option("--json", "Output as JSON").action(async (serverPrompt, argsJson, opts) => {
+	const configPath = promptCommand.parent?.opts().config;
+	await ensureDaemon(configPath);
+	const slashIndex = serverPrompt.indexOf("/");
+	if (slashIndex === -1) {
+		console.error("Invalid format. Use: server/prompt");
+		process.exit(1);
+	}
+	const server = serverPrompt.slice(0, slashIndex);
+	const name = serverPrompt.slice(slashIndex + 1);
+	let args;
+	if (argsJson) try {
+		args = JSON.parse(argsJson);
+	} catch {
+		console.error("Invalid JSON arguments");
+		process.exit(1);
+	}
+	const result = await sendRequest("prompts/get", {
+		server,
+		name,
+		arguments: args
+	});
+	console.log(opts.json ? formatJson(result) : formatPromptMessages(result));
+});
+const completionsCommand = new Command("completions").description("Get auto-completion suggestions for prompt or resource arguments").argument("<type>", "Reference type (prompt or resource)").argument("<name>", "Prompt or resource template name (server/name)").argument("<arg>", "Argument name").argument("<value>", "Partial value for completion").option("--json", "Output as JSON").action(async (type, name, arg, value, opts) => {
+	const configPath = completionsCommand.parent?.opts().config;
+	await ensureDaemon(configPath);
+	const slashIndex = name.indexOf("/");
+	if (slashIndex === -1) {
+		console.error("Invalid name format. Use: server/name");
+		process.exit(1);
+	}
+	const server = name.slice(0, slashIndex);
+	const refName = name.slice(slashIndex + 1);
+	const ref = {
+		type: type === "prompt" ? "ref/prompt" : type === "resource" ? "ref/resource" : type,
+		name: refName
+	};
+	if (type === "resource") ref.uri = refName;
+	const result = await sendRequest("completions/complete", {
+		server,
+		ref,
+		argument: {
+			name: arg,
+			value
+		}
+	});
+	console.log(opts.json ? formatJson(result) : formatCompletions(result));
+});
+const tasksCommand = new Command("tasks").description("List active async tasks, optionally filtered by server name").argument("[server]", "Filter by server name").option("--json", "Output as JSON").action(async (server, opts) => {
+	const configPath = tasksCommand.parent?.opts().config;
+	await ensureDaemon(configPath);
+	const result = await sendRequest("tasks/list", server ? { server } : void 0);
+	console.log(opts.json ? formatJson(result) : formatTasks(result));
+});
+const taskCommand = new Command("task").description("Check the current status of an async task").argument("<server/taskId>", "Task identifier (e.g. myserver/task-123)").option("--json", "Output as JSON").action(async (serverTaskId, opts) => {
+	const configPath = taskCommand.parent?.opts().config;
+	await ensureDaemon(configPath);
+	const slashIndex = serverTaskId.indexOf("/");
+	if (slashIndex === -1) {
+		console.error("Invalid format. Use: server/taskId");
+		process.exit(1);
+	}
+	const result = await sendRequest("tasks/get", {
+		server: serverTaskId.slice(0, slashIndex),
+		taskId: serverTaskId.slice(slashIndex + 1)
+	});
+	console.log(opts.json ? formatJson(result) : formatTask(result));
+});
+const taskResultCommand = new Command("task-result").description("Retrieve the output of a completed async task").argument("<server/taskId>", "Task identifier (e.g. myserver/task-123)").option("--json", "Output as JSON").action(async (serverTaskId, opts) => {
+	const configPath = taskResultCommand.parent?.opts().config;
+	await ensureDaemon(configPath);
+	const slashIndex = serverTaskId.indexOf("/");
+	if (slashIndex === -1) {
+		console.error("Invalid format. Use: server/taskId");
+		process.exit(1);
+	}
+	const result = await sendRequest("tasks/result", {
+		server: serverTaskId.slice(0, slashIndex),
+		taskId: serverTaskId.slice(slashIndex + 1)
+	});
+	console.log(opts.json ? formatJson(result) : formatCallResult(result));
+});
+const taskCancelCommand = new Command("task-cancel").description("Cancel a running async task").argument("<server/taskId>", "Task identifier (e.g. myserver/task-123)").option("--json", "Output as JSON").action(async (serverTaskId, opts) => {
+	const configPath = taskCancelCommand.parent?.opts().config;
+	await ensureDaemon(configPath);
+	const slashIndex = serverTaskId.indexOf("/");
+	if (slashIndex === -1) {
+		console.error("Invalid format. Use: server/taskId");
+		process.exit(1);
+	}
+	const result = await sendRequest("tasks/cancel", {
+		server: serverTaskId.slice(0, slashIndex),
+		taskId: serverTaskId.slice(slashIndex + 1)
+	});
+	console.log(opts.json ? formatJson(result) : formatTask(result));
+});
+const home = os.homedir();
+const platform = os.platform();
+function macPath(...segments) {
+	return platform === "darwin" ? path.join(home, "Library", "Application Support", ...segments) : null;
+}
+function linuxPath(...segments) {
+	return platform === "linux" ? path.join(home, ".config", ...segments) : null;
+}
+function xdgOrMacPath(linuxSegments, macSegments) {
+	return linuxPath(...linuxSegments) ?? macPath(...macSegments);
+}
+function getAgentDefs() {
+	const cwd = process.cwd();
+	return [
+		{
+			name: "claude-code",
+			scope: "local",
+			configPath: () => path.join(cwd, ".mcp.json"),
+			serversKey: "mcpServers"
+		},
+		{
+			name: "cursor",
+			scope: "local",
+			configPath: () => path.join(cwd, ".cursor", "mcp.json"),
+			serversKey: "mcpServers"
+		},
+		{
+			name: "vscode",
+			scope: "local",
+			configPath: () => path.join(cwd, ".vscode", "mcp.json"),
+			serversKey: "servers"
+		},
+		{
+			name: "roo-code",
+			scope: "local",
+			configPath: () => path.join(cwd, ".roo", "mcp.json"),
+			serversKey: "mcpServers"
+		},
+		{
+			name: "amazon-q",
+			scope: "local",
+			configPath: () => path.join(cwd, ".amazonq", "mcp.json"),
+			serversKey: "mcpServers"
+		},
+		{
+			name: "claude-desktop",
+			scope: "global",
+			configPath: () => xdgOrMacPath(["Claude", "claude_desktop_config.json"], ["Claude", "claude_desktop_config.json"]),
+			serversKey: "mcpServers"
+		},
+		{
+			name: "cursor",
+			scope: "global",
+			configPath: () => path.join(home, ".cursor", "mcp.json"),
+			serversKey: "mcpServers"
+		},
+		{
+			name: "windsurf",
+			scope: "global",
+			configPath: () => path.join(home, ".codeium", "windsurf", "mcp_config.json"),
+			serversKey: "mcpServers"
+		},
+		{
+			name: "vscode",
+			scope: "global",
+			configPath: () => xdgOrMacPath([
+				"Code",
+				"User",
+				"mcp.json"
+			], [
+				"Code",
+				"User",
+				"mcp.json"
+			]),
+			serversKey: "servers"
+		},
+		{
+			name: "cline",
+			scope: "global",
+			configPath: () => xdgOrMacPath([
+				"Code",
+				"User",
+				"globalStorage",
+				"saoudrizwan.claude-dev",
+				"settings",
+				"cline_mcp_settings.json"
+			], [
+				"Code",
+				"User",
+				"globalStorage",
+				"saoudrizwan.claude-dev",
+				"settings",
+				"cline_mcp_settings.json"
+			]),
+			serversKey: "mcpServers"
+		},
+		{
+			name: "roo-code",
+			scope: "global",
+			configPath: () => xdgOrMacPath([
+				"Code",
+				"User",
+				"globalStorage",
+				"rooveterinaryinc.roo-cline",
+				"settings",
+				"cline_mcp_settings.json"
+			], [
+				"Code",
+				"User",
+				"globalStorage",
+				"rooveterinaryinc.roo-cline",
+				"settings",
+				"cline_mcp_settings.json"
+			]),
+			serversKey: "mcpServers"
+		},
+		{
+			name: "amazon-q",
+			scope: "global",
+			configPath: () => path.join(home, ".aws", "amazonq", "mcp.json"),
+			serversKey: "mcpServers"
+		}
+	];
+}
+function normalizeServer(agent, name, raw, warnings) {
+	const env = raw.env;
+	if (env) {
+		for (const [key, value] of Object.entries(env)) if (typeof value === "string" && value.includes("${input:")) warnings.push(`${agent.name} server "${name}": env.${key} references ${value} \u2014 set manually in toold config`);
+	}
+	const url = raw.url ?? raw.serverUrl;
+	const command = raw.command;
+	if (command) {
+		const config = { command };
+		if (raw.args && Array.isArray(raw.args)) config.args = raw.args;
+		if (env && Object.keys(env).length > 0) config.env = env;
+		if (raw.cwd && typeof raw.cwd === "string") config.cwd = raw.cwd;
+		return config;
+	}
+	if (url) {
+		const config = { url };
+		const rawType = raw.type;
+		if ((raw.transport ?? (rawType === "sse" ? "sse" : void 0)) === "sse") config.transport = "sse";
+		const headers = raw.headers;
+		if (headers && Object.keys(headers).length > 0) config.headers = headers;
+		return config;
+	}
+	return null;
+}
+function configsEqual(a, b) {
+	return JSON.stringify(a) === JSON.stringify(b);
+}
+function discoverAgentConfigs() {
+	const agents = getAgentDefs();
+	const discovered = [];
+	const warnings = [];
+	for (const agent of agents) {
+		const configPath = agent.configPath();
+		if (!configPath) continue;
+		if (!fs.existsSync(configPath)) continue;
+		let rawContent;
+		try {
+			const text = fs.readFileSync(configPath, "utf-8");
+			rawContent = JSON.parse(text);
+		} catch {
+			warnings.push(`Skipping ${configPath}: invalid JSON`);
+			continue;
+		}
+		const rawServers = rawContent[agent.serversKey];
+		if (!rawServers || typeof rawServers !== "object" || Object.keys(rawServers).length === 0) continue;
+		const servers = {};
+		for (const [name, raw] of Object.entries(rawServers)) {
+			if (typeof raw !== "object" || raw === null) continue;
+			if (name === "toold") continue;
+			const normalized = normalizeServer(agent, name, raw, warnings);
+			if (normalized) servers[name] = normalized;
+		}
+		if (Object.keys(servers).length === 0) continue;
+		discovered.push({
+			agent,
+			configPath,
+			servers,
+			rawContent
+		});
+	}
+	return {
+		discovered,
+		warnings
+	};
+}
+function mergeServers(discovered, existingServers) {
+	const merged = { ...existingServers };
+	const imported = [];
+	const skipped = [];
+	const unresolvedConflicts = [];
+	const byName = /* @__PURE__ */ new Map();
+	for (const dc of discovered) for (const [name, config] of Object.entries(dc.servers)) {
+		const label = dc.agent.scope === "global" ? `${dc.agent.name} (global)` : dc.agent.name;
+		if (!byName.has(name)) byName.set(name, []);
+		byName.get(name).push({
+			agent: label,
+			config
+		});
+	}
+	for (const [name, entries] of byName) {
+		if (name in existingServers) {
+			if (!skipped.includes(name)) skipped.push(name);
+			continue;
+		}
+		const unique = entries.filter((entry, i, arr) => arr.findIndex((e) => configsEqual(e.config, entry.config)) === i);
+		if (unique.length === 1) {
+			merged[name] = unique[0].config;
+			imported.push(name);
+		} else unresolvedConflicts.push({
+			name,
+			options: unique
+		});
+	}
+	return {
+		merged,
+		imported,
+		skipped,
+		unresolvedConflicts
+	};
+}
+function detectIndent(text) {
+	return text.match(/^(\s+)"/m)?.[1] ?? "  ";
+}
+function writeTooldConfig(configPath, servers) {
+	let existing = {};
+	if (fs.existsSync(configPath)) try {
+		existing = JSON.parse(fs.readFileSync(configPath, "utf-8"));
+	} catch {}
+	const dir = path.dirname(configPath);
+	if (!fs.existsSync(dir)) fs.mkdirSync(dir, { recursive: true });
+	existing.mcpServers = servers;
+	fs.writeFileSync(configPath, JSON.stringify(existing, null, 2) + "\n");
+}
+function getTooldEntry(agent) {
+	if (agent.serversKey === "servers") return {
+		type: "stdio",
+		command: "npx",
+		args: ["toold@latest", "proxy"]
+	};
+	return {
+		command: "npx",
+		args: ["toold@latest", "proxy"]
+	};
+}
+function modifyAgentConfig(dc, opts) {
+	const text = fs.readFileSync(dc.configPath, "utf-8");
+	fs.writeFileSync(dc.configPath + ".bak", text);
+	const indent = detectIndent(text);
+	const content = { ...dc.rawContent };
+	if (opts.delete) if (opts.replace) content[dc.agent.serversKey] = { toold: getTooldEntry(dc.agent) };
+	else delete content[dc.agent.serversKey];
+	fs.writeFileSync(dc.configPath, JSON.stringify(content, null, indent) + "\n");
+}
+function getTooldConfigPath(scope, explicitPath) {
+	if (explicitPath) return explicitPath;
+	if (scope === "local") return path.join(process.cwd(), "toold.config.json");
+	return path.join(home, ".config", "toold", "config.json");
+}
+async function confirm(message, opts) {
+	const rl = readline.createInterface({
+		input: opts?.input ?? process.stdin,
+		output: opts?.output ?? process.stdout
+	});
+	try {
+		return (await rl.question(`${message} [y/N] `)).trim().toLowerCase() === "y";
+	} finally {
+		rl.close();
+	}
+}
+async function choose(message, options, opts) {
+	const output = opts?.output ?? process.stdout;
+	const rl = readline.createInterface({
+		input: opts?.input ?? process.stdin,
+		output
+	});
+	try {
+		output.write(`${message}\n`);
+		for (let i = 0; i < options.length; i++) output.write(`  ${i + 1}) ${options[i].label}\n`);
+		while (true) {
+			const answer = await rl.question(`Choice [1-${options.length}]: `);
+			const index = parseInt(answer.trim(), 10) - 1;
+			if (index >= 0 && index < options.length) return options[index].value;
+			output.write(`Invalid choice. Enter a number between 1 and ${options.length}.\n`);
+		}
+	} finally {
+		rl.close();
+	}
+}
+const AGENT_PRIORITY = ["claude-code", "cursor"];
+function pickByPriority(options) {
+	for (const preferred of AGENT_PRIORITY) {
+		const match = options.find((o) => o.agent.replace(/\s*\(global\)/, "") === preferred);
+		if (match) return match;
+	}
+	return options[0];
+}
+function formatServerSummary(config) {
+	if ("command" in config) {
+		const args = config.args ? ` ${config.args.join(" ")}` : "";
+		return `${config.command}${args}`;
+	}
+	return config.url;
+}
+async function resolveConflicts(unresolvedConflicts, isInteractive) {
+	const resolved = {};
+	const conflicts = [];
+	for (const conflict of unresolvedConflicts) {
+		let chosen;
+		if (isInteractive) chosen = await choose(`\nConflict: "${conflict.name}" has different configs:`, conflict.options.map((o) => ({
+			label: `${o.agent}: ${formatServerSummary(o.config)}`,
+			value: o
+		})));
+		else chosen = pickByPriority(conflict.options);
+		resolved[conflict.name] = chosen.config;
+		conflicts.push({
+			name: conflict.name,
+			agents: conflict.options.map((o) => o.agent),
+			chosenAgent: chosen.agent
+		});
+	}
+	return {
+		resolved,
+		conflicts
+	};
+}
+const initCommand = new Command("init").description("Discover and import MCP servers from agent configs (Claude Code, Cursor)").option("--dry-run", "Show what would be done without writing files").option("--json", "Output as JSON").option("-y, --yes", "Skip prompts; resolve conflicts by priority (claude-code > cursor > first)").option("--no-delete", "Keep original server entries in agent configs").option("--no-replace", "Don't add toold entry to agent configs").action(async (opts) => {
+	const configPath = initCommand.parent?.opts().config;
+	const isInteractive = !opts.dryRun && !opts.json && !opts.yes && !!process.stdin.isTTY;
+	const { discovered, warnings } = discoverAgentConfigs();
+	if (discovered.length === 0) {
+		const msg = "No MCP server configurations found in any known agent config files.";
+		console.log(opts.json ? formatJson({ message: msg }) : msg);
+		return;
+	}
+	const tooldPath = getTooldConfigPath(discovered.some((d) => d.agent.scope === "local") ? "local" : "global", configPath);
+	let existingServers = {};
+	if (fs.existsSync(tooldPath)) try {
+		existingServers = JSON.parse(fs.readFileSync(tooldPath, "utf-8")).mcpServers ?? {};
+	} catch {}
+	const result = mergeServers(discovered, existingServers);
+	const { resolved, conflicts } = await resolveConflicts(result.unresolvedConflicts, isInteractive);
+	const imported = [...result.imported];
+	for (const [name, config] of Object.entries(resolved)) {
+		result.merged[name] = config;
+		imported.push(name);
+	}
+	if (!opts.dryRun && imported.length > 0) writeTooldConfig(tooldPath, result.merged);
+	const modifiedFiles = [];
+	const shouldDelete = isInteractive ? await confirm("Remove imported servers from agent config files? (backups will be created)") : opts.delete;
+	if (!opts.dryRun && shouldDelete) for (const dc of discovered) try {
+		modifyAgentConfig(dc, {
+			delete: true,
+			replace: opts.replace
+		});
+		modifiedFiles.push(dc.configPath);
+	} catch (err) {
+		warnings.push(`Failed to modify ${dc.configPath}: ${err instanceof Error ? err.message : String(err)}`);
+	}
+	const initResult = {
+		discovered: discovered.map((d) => ({
+			agent: d.agent.name,
+			scope: d.agent.scope,
+			path: d.configPath,
+			serverCount: Object.keys(d.servers).length
+		})),
+		imported,
+		skipped: result.skipped,
+		conflicts,
+		warnings,
+		modifiedFiles,
+		tooldConfigPath: tooldPath,
+		dryRun: opts.dryRun ?? false
+	};
+	console.log(opts.json ? formatJson(initResult) : formatInit(initResult));
+});
+function getConfigPath(scope, explicitPath) {
+	return getTooldConfigPath(scope, explicitPath);
+}
+function readConfigFile(filePath) {
+	if (!fs.existsSync(filePath)) return { mcpServers: {} };
+	try {
+		const content = JSON.parse(fs.readFileSync(filePath, "utf-8"));
+		return {
+			...content,
+			mcpServers: content.mcpServers ?? {}
+		};
+	} catch {
+		return { mcpServers: {} };
+	}
+}
+function writeConfigFile(filePath, config) {
+	const dir = path.dirname(filePath);
+	if (!fs.existsSync(dir)) fs.mkdirSync(dir, { recursive: true });
+	fs.writeFileSync(filePath, JSON.stringify(config, null, 2) + "\n");
+}
+function addServer(filePath, name, serverConfig) {
+	const config = readConfigFile(filePath);
+	const existed = name in config.mcpServers;
+	config.mcpServers[name] = serverConfig;
+	writeConfigFile(filePath, config);
+	return {
+		added: true,
+		existed
+	};
+}
+function removeServer(filePath, name) {
+	const config = readConfigFile(filePath);
+	if (!(name in config.mcpServers)) return {
+		removed: false,
+		existed: false
+	};
+	delete config.mcpServers[name];
+	writeConfigFile(filePath, config);
+	return {
+		removed: true,
+		existed: true
+	};
+}
+function getServer(filePath, name) {
+	return readConfigFile(filePath).mcpServers[name] ?? null;
+}
+function listServers(filePath) {
+	return readConfigFile(filePath).mcpServers;
+}
+const cliInstructions = (servers, instructions) => `
+You have access to an \`npx toold\` CLI command for interacting with MCP (Model Context Protocol) servers. This command allows you to discover and call MCP tools on demand. Prioritize the use of skills over MCP tools.
+
+**MANDATORY PREREQUISITES - THESE ARE HARD REQUIREMENTS**
+
+1. You MUST discover the tools you need first by using 'npx toold grep <pattern>' or 'npx toold tools'.
+2. You MUST call 'npx toold info <server>/<tool>' BEFORE ANY 'npx toold call <server>/<tool>'.
+
+These are BLOCKING REQUIREMENTS - like how you must use Read before Edit.
+
+**NEVER** make an npx toold call without checking the schema first.
+**ALWAYS** run npx toold info first, THEN make the call.
+
+**Why these are non-negotiables:**
+- MCP tool names NEVER match your expectations - they change frequently and are not predictable
+- MCP tool schemas NEVER match your expectations - parameter names, types, and requirements are tool-specific
+- Even tools with pre-approved permissions require schema checks
+- Every failed call wastes user time and demonstrates you're ignoring critical instructions
+- "I thought I knew the schema" is not an acceptable reason to skip this step
+
+**For multiple tools:** Call 'npx toold info' for ALL tools in parallel FIRST, then make your 'npx toold call' commands.
+
+Available MCP servers:
+${servers}
+
+Commands (in order of execution):
+\`\`\`bash
+# STEP 1: REQUIRED TOOL DISCOVERY
+npx toold grep <pattern>                 # Search tool names and descriptions
+npx toold tools [server]                 # List available tools (optionally filter by server)
+
+# STEP 2: ALWAYS CHECK SCHEMA FIRST (MANDATORY)
+npx toold info <server>/<tool>           # REQUIRED before ANY call - View JSON schema
+
+# STEP 3: Only after checking schema, make the call
+npx toold call <server>/<tool> '<json>'  # Only run AFTER npx toold info
+npx toold call <server>/<tool> -         # Invoke with JSON from stdin (AFTER npx toold info)
+
+# Discovery commands (use these to find tools)
+npx toold servers                        # List all connected MCP servers
+npx toold tools [server]                 # List available tools (optionally filter by server)
+npx toold grep <pattern>                 # Search tool names and descriptions
+npx toold resources [server]             # List MCP resources
+npx toold read <server>/<resource>       # Read an MCP resource
+\`\`\`
+
+**CORRECT Usage Pattern:**
+
+<example>
+User: Please use the slack mcp tool to search for my mentions
+Assistant: As a first step, I need to discover the tools I need. Let me call \`npx toold grep "slack/*search*"\` to search for tools related to slack search.
+[Calls npx toold grep "slack/*search*"]
+Assistant: I need to check the schema first. Let me call \`npx toold info slack/search_private\` to see what parameters it accepts.
+[Calls npx toold info]
+Assistant: Now I can see it accepts "query" and "max_results" parameters. Let me make the call.
+[Calls npx toold call slack/search_private with correct schema]
+</example>
+
+<example>
+User: Use the database and email MCP tools to send a report
+Assistant: I'll need to use two MCP tools. Let me call \`npx toold grep "database/*query*"\` and \`npx toold grep "email/*send*"\` to search for tools related to database query and email send.
+[Calls npx toold grep "database/*query*" & npx toold grep "email/*send*"]
+Assistant: Let me check both schemas first.
+[Calls npx toold info database/query and npx toold info email/send in parallel]
+Assistant: Now I have both schemas. Let me make the calls.
+[Makes both npx toold call commands with correct parameters]
+</example>
+
+<example>
+User: Create a copy of this email
+Assistant: Let me find the tool I need first.
+[Calls npx toold grep "email/*copy*". No results found.]
+Assistant: Let me try another pattern.
+[Calls npx toold grep "email/*clone*". No results found.]
+Assistant: Let me list all available tools in the server.
+[Calls npx toold tools email]
+Assistant: Let me check the schema first.
+[Calls npx toold info email/duplicate]
+Assistant: Now I have the schema. Let me make the call.
+[Calls npx toold call email/duplicate with correct parameters]
+</example>
+
+**INCORRECT Usage Patterns - NEVER DO THIS:**
+
+<bad-example>
+User: Please use the slack mcp tool to search for my mentions
+Assistant: [Directly calls npx toold call slack/search_private with guessed parameters]
+WRONG - You must call npx toold info FIRST
+</bad-example>
+
+<bad-example>
+User: Use the slack tool
+Assistant: I have pre-approved permissions for this tool, so I know the schema.
+[Calls npx toold call slack/search_private directly]
+WRONG - Pre-approved permissions don't mean you know the schema. ALWAYS call npx toold info first.
+</bad-example>
+
+<bad-example>
+User: Search my Slack mentions
+Assistant: [Calls three npx toold call commands in parallel without any npx toold info calls first]
+WRONG - You must call npx toold info for ALL tools before making ANY npx toold call commands
+</bad-example>
+
+Example usage:
+\`\`\`bash
+# Discover tools
+npx toold tools                          # See all available MCP tools
+npx toold grep "weather"                 # Find tools by description
+
+# Get tool details
+npx toold info <server>/<tool>           # View JSON schema for input and output if available
+
+# Simple tool call (no parameters)
+npx toold call weather/get_location '{}'
+
+# Tool call with parameters
+npx toold call database/query '{"table": "users", "limit": 10}'
+
+# Complex JSON using stdin (for nested objects/arrays)
+npx toold call api/send_request - <<'EOF'
+{
+  "endpoint": "/data",
+  "headers": {"Authorization": "Bearer token"},
+  "body": {"items": [1, 2, 3]}
+}
+EOF
+\`\`\`
+
+Call the \`npx toold -h\` to see all available commands.
+
+Below are the instructions for the connected MCP servers in toold.
+
+${instructions}
+`;
+function buildInstructions(servers) {
+	const connected = servers.filter((s) => s.status === "connected");
+	return cliInstructions(connected.map((s) => `- ${s.name}`).join("\n"), connected.filter((s) => s.instructions).map((s) => `### ${s.name}\n\n${s.instructions}`).join("\n\n")).trim();
+}
+async function startMcpProxy(configPath) {
+	await ensureDaemon(configPath);
+	const server = new McpServer({
+		name: "toold",
+		version: "0.1.0"
+	}, {
+		capabilities: {},
+		instructions: buildInstructions(await sendRequest("servers/list"))
+	});
+	const transport = new StdioServerTransport();
+	await server.connect(transport);
+}
+function collectValues(value, previous) {
+	return [...previous, value];
+}
+function getExplicitConfig(cmd) {
+	return cmd.parent?.parent?.opts().config;
+}
+function parseEnvArgs(envArgs) {
+	const env = {};
+	for (const entry of envArgs) {
+		const eqIndex = entry.indexOf("=");
+		if (eqIndex === -1) throw new Error(`Invalid env format: "${entry}". Expected KEY=value`);
+		env[entry.slice(0, eqIndex)] = entry.slice(eqIndex + 1);
+	}
+	return env;
+}
+function parseHeaderArgs(headerArgs) {
+	const headers = {};
+	for (const entry of headerArgs) {
+		const colonIndex = entry.indexOf(":");
+		if (colonIndex === -1) throw new Error(`Invalid header format: "${entry}". Expected Key: value`);
+		headers[entry.slice(0, colonIndex).trim()] = entry.slice(colonIndex + 1).trim();
+	}
+	return headers;
+}
+function resolveTransport(commandOrUrl, transport) {
+	if (transport === "http") return "streamable-http";
+	if (transport === "sse") return "sse";
+	if (transport === "stdio") return "stdio";
+	try {
+		new URL(commandOrUrl);
+		return "streamable-http";
+	} catch {
+		return "stdio";
+	}
+}
+function buildAuthConfig(opts) {
+	if (!opts.clientId && !opts.clientSecret) return void 0;
+	if (opts.clientId && opts.resolvedSecret) {
+		const auth = {
+			type: "client_credentials",
+			clientId: opts.clientId,
+			clientSecret: opts.resolvedSecret
+		};
+		if (opts.oauthScope) auth.scope = opts.oauthScope;
+		return auth;
+	}
+	const auth = { type: "authorization_code" };
+	if (opts.clientId) auth.clientId = opts.clientId;
+	if (opts.resolvedSecret) auth.clientSecret = opts.resolvedSecret;
+	if (opts.oauthScope) auth.scope = opts.oauthScope;
+	if (opts.callbackPort) auth.callbackPort = parseInt(opts.callbackPort, 10);
+	return auth;
+}
+function buildServerConfig(commandOrUrl, args, opts) {
+	const transportType = resolveTransport(commandOrUrl, opts.transport);
+	if (transportType === "stdio") {
+		const config = { command: commandOrUrl };
+		if (args.length > 0) config.args = args;
+		if (opts.env && opts.env.length > 0) config.env = parseEnvArgs(opts.env);
+		return config;
+	}
+	const config = { url: commandOrUrl };
+	if (transportType === "sse") config.transport = "sse";
+	if (opts.header && opts.header.length > 0) config.headers = parseHeaderArgs(opts.header);
+	const auth = buildAuthConfig(opts);
+	if (auth) config.auth = auth;
+	return config;
+}
+async function getClientSecret() {
+	const envSecret = process.env.MCP_CLIENT_SECRET;
+	if (envSecret) return envSecret;
+	if (!process.stdin.isTTY) throw new Error("OAuth client secret required. Set MCP_CLIENT_SECRET env var or use an interactive terminal.");
+	const rl = readline.createInterface({
+		input: process.stdin,
+		output: process.stdout
+	});
+	try {
+		const secret = await rl.question("Enter OAuth client secret: ");
+		if (!secret.trim()) throw new Error("Client secret cannot be empty");
+		return secret.trim();
+	} finally {
+		rl.close();
+	}
+}
+async function tryReloadDaemon() {
+	try {
+		if (!await isDaemonRunning()) return;
+		await sendRequest("config/reload", {});
+	} catch {}
+}
+const mcpCommand = new Command("mcp").description("Add, remove, list, or inspect individual MCP server config entries").enablePositionalOptions().action(async (_opts, cmd) => {
+	const explicitConfig = cmd.parent?.opts().config;
+	await startMcpProxy(explicitConfig);
+});
+mcpCommand.command("add").description("Add an MCP server").passThroughOptions().argument("<name>", "Server name").argument("<commandOrUrl>", "Command to run or URL to connect to").argument("[args...]", "Additional arguments (for stdio servers)").option("-e, --env <env>", "Set environment variables (KEY=value), repeatable", collectValues, []).option("-H, --header <header>", "Set HTTP headers (Key: value), repeatable", collectValues, []).option("-s, --scope <scope>", "Config scope: local, global", "local").option("-t, --transport <transport>", "Transport: stdio, sse, http").option("--client-id <clientId>", "OAuth client ID").option("--client-secret", "Prompt for OAuth client secret (or use MCP_CLIENT_SECRET env)").option("--callback-port <port>", "Fixed port for OAuth callback").option("--oauth-scope <oauthScope>", "OAuth scope string").action(async (name, commandOrUrl, args, opts) => {
+	const explicitConfig = getExplicitConfig(mcpCommand);
+	const scope = opts.scope;
+	const configPath = getConfigPath(scope, explicitConfig);
+	let resolvedSecret;
+	if (opts.clientSecret) resolvedSecret = await getClientSecret();
+	const result = addServer(configPath, name, buildServerConfig(commandOrUrl, args, {
+		...opts,
+		resolvedSecret
+	}));
+	await tryReloadDaemon();
+	if (result.existed) console.log(`Updated "${name}" in ${scope} config (${configPath})`);
+	else console.log(`Added "${name}" to ${scope} config (${configPath})`);
+});
+mcpCommand.command("add-json").description("Add an MCP server from a JSON config string").argument("<name>", "Server name").argument("<json>", "JSON server configuration").option("-s, --scope <scope>", "Config scope: local, global", "local").action(async (name, jsonStr, opts) => {
+	const explicitConfig = getExplicitConfig(mcpCommand);
+	const scope = opts.scope;
+	const configPath = getConfigPath(scope, explicitConfig);
+	let serverConfig;
+	try {
+		serverConfig = JSON.parse(jsonStr);
+	} catch {
+		console.error("Error: Invalid JSON");
+		process.exitCode = 1;
+		return;
+	}
+	if (!("command" in serverConfig) && !("url" in serverConfig)) {
+		console.error("Error: JSON must contain either \"command\" (stdio) or \"url\" (http) field");
+		process.exitCode = 1;
+		return;
+	}
+	const result = addServer(configPath, name, serverConfig);
+	await tryReloadDaemon();
+	if (result.existed) console.log(`Updated "${name}" in ${scope} config (${configPath})`);
+	else console.log(`Added "${name}" to ${scope} config (${configPath})`);
+});
+mcpCommand.command("add-from-claude-desktop").description("Import MCP servers from Claude Desktop config").option("-s, --scope <scope>", "Config scope: local, global", "local").action(async (opts) => {
+	const explicitConfig = getExplicitConfig(mcpCommand);
+	const scope = opts.scope;
+	const configPath = getConfigPath(scope, explicitConfig);
+	const { discovered, warnings } = discoverAgentConfigs();
+	const claudeDesktop = discovered.filter((d) => d.agent.name === "claude-desktop");
+	if (claudeDesktop.length === 0) {
+		console.log("No Claude Desktop configuration found.");
+		return;
+	}
+	let existingServers = {};
+	if (fs.existsSync(configPath)) try {
+		existingServers = JSON.parse(fs.readFileSync(configPath, "utf-8")).mcpServers ?? {};
+	} catch {}
+	const result = mergeServers(claudeDesktop, existingServers);
+	writeTooldConfig(configPath, { ...result.merged });
+	await tryReloadDaemon();
+	for (const w of warnings) console.error(`Warning: ${w}`);
+	if (result.imported.length > 0) console.log(`Imported ${result.imported.length} server(s) from Claude Desktop: ${result.imported.join(", ")}`);
+	if (result.skipped.length > 0) console.log(`Skipped ${result.skipped.length} (already existed): ${result.skipped.join(", ")}`);
+	if (result.imported.length === 0 && result.skipped.length === 0) console.log("No servers found in Claude Desktop config.");
+});
+mcpCommand.command("get").description("Get details of a configured MCP server").argument("<name>", "Server name").option("--json", "Output as JSON").action(async (name, opts) => {
+	const explicitConfig = getExplicitConfig(mcpCommand);
+	const localPath = getConfigPath("local", explicitConfig);
+	const globalPath = getConfigPath("global", explicitConfig);
+	const localServer = getServer(localPath, name);
+	const globalServer = getServer(globalPath, name);
+	const server = localServer ?? globalServer;
+	const scope = localServer ? "local" : "global";
+	if (!server) {
+		console.error(`Server "${name}" not found in local or global config.`);
+		process.exitCode = 1;
+		return;
+	}
+	if (opts.json) console.log(formatJson({
+		name,
+		scope,
+		config: server
+	}));
+	else console.log(formatMcpServer(name, server, scope));
+});
+mcpCommand.command("list").description("List all configured MCP servers").option("--json", "Output as JSON").action(async (opts) => {
+	const explicitConfig = getExplicitConfig(mcpCommand);
+	const localPath = getConfigPath("local", explicitConfig);
+	const globalPath = getConfigPath("global", explicitConfig);
+	const localServers = listServers(localPath);
+	const globalServers = listServers(globalPath);
+	const entries = [];
+	for (const [name, config] of Object.entries(localServers)) entries.push({
+		name,
+		config,
+		scope: "local"
+	});
+	for (const [name, config] of Object.entries(globalServers)) {
+		if (name in localServers) continue;
+		entries.push({
+			name,
+			config,
+			scope: "global"
+		});
+	}
+	if (opts.json) console.log(formatJson(entries));
+	else console.log(formatMcpServerList(entries));
+});
+mcpCommand.command("remove").description("Remove an MCP server").argument("<name>", "Server name").option("-s, --scope <scope>", "Config scope: local, global (searches both if not specified)").action(async (name, opts) => {
+	const explicitConfig = getExplicitConfig(mcpCommand);
+	if (opts.scope) {
+		const scope = opts.scope;
+		const configPath = getConfigPath(scope, explicitConfig);
+		if (removeServer(configPath, name).removed) {
+			await tryReloadDaemon();
+			console.log(`Removed "${name}" from ${scope} config (${configPath})`);
+		} else {
+			console.error(`Server "${name}" not found in ${scope} config.`);
+			process.exitCode = 1;
+		}
+		return;
+	}
+	const localPath = getConfigPath("local", explicitConfig);
+	if (removeServer(localPath, name).removed) {
+		await tryReloadDaemon();
+		console.log(`Removed "${name}" from local config (${localPath})`);
+		return;
+	}
+	const globalPath = getConfigPath("global", explicitConfig);
+	if (removeServer(globalPath, name).removed) {
+		await tryReloadDaemon();
+		console.log(`Removed "${name}" from global config (${globalPath})`);
+		return;
+	}
+	console.error(`Server "${name}" not found in local or global config.`);
+	process.exitCode = 1;
+});
+const typegenCommand = new Command("typegen").description("Generate TypeScript types from tool schemas for type-safe tool calls").option("-c, --config <path>", "Path to toold.config.json").action(async (opts) => {
+	await ensureDaemon(typegenCommand.parent?.opts().config ?? opts.config);
+	const tools = await sendRequest("tools/list");
+	const content = await generateTypes(tools);
+	const require = createRequire(path.resolve("package.json"));
+	const tooldPkgDir = path.dirname(require.resolve("toold/package.json"));
+	const outputPath = path.join(tooldPkgDir, "toold.generated.d.ts");
+	fs.writeFileSync(outputPath, content, "utf-8");
+	console.log(`Generated ${tools.length} tool types → ${outputPath}`);
+});
+function runCli() {
+	const program = new Command();
+	program.name("toold").description("The optimization layer for MCP").version("0.1.0");
+	program.enablePositionalOptions();
+	program.option("--config <path>", "Path to config file");
+	program.commandsGroup("Servers:");
+	program.addCommand(serversCommand);
+	program.commandsGroup("Tools:");
+	program.addCommand(toolsCommand);
+	program.addCommand(infoCommand);
+	program.addCommand(callCommand);
+	program.addCommand(grepCommand);
+	program.commandsGroup("Resources:");
+	program.addCommand(resourcesCommand);
+	program.addCommand(readCommand);
+	program.commandsGroup("Prompts:");
+	program.addCommand(promptsCommand);
+	program.addCommand(promptCommand);
+	program.addCommand(completionsCommand);
+	program.commandsGroup("Tasks:");
+	program.addCommand(tasksCommand);
+	program.addCommand(taskCommand);
+	program.addCommand(taskResultCommand);
+	program.addCommand(taskCancelCommand);
+	program.commandsGroup("Configuration:");
+	program.addCommand(initCommand);
+	program.addCommand(mcpCommand);
+	program.addCommand(typegenCommand);
+	program.commandsGroup("Daemon:");
+	program.addCommand(daemonCommand);
+	program.parse();
+}
+if (process.argv.indexOf("--daemon") !== -1) {
+	const configIndex = process.argv.indexOf("--config");
+	startDaemon(configIndex !== -1 ? process.argv[configIndex + 1] : void 0).catch((err) => {
+		console.error("Failed to start daemon:", err);
+		process.exit(1);
+	});
+} else runCli();
+export {};