muxed 0.1.0

package/dist/client/index.d.mts

@@ -0,0 +1,171 @@
+import { CompleteResult, GetPromptResult, Implementation, Prompt, Prompt as Prompt$1, ReadResourceResult, Resource, Resource as Resource$1, ServerCapabilities, Tool, Tool as Tool$1 } from "@modelcontextprotocol/sdk/types.js";
+
+//#region src/core/types.d.ts
+type StdioServerConfig = {
+  command: string;
+  args?: string[];
+  env?: Record<string, string>;
+  cwd?: string;
+};
+type ClientCredentialsAuth = {
+  type: 'client_credentials';
+  clientId: string;
+  clientSecret: string;
+  scope?: string;
+};
+type AuthorizationCodeAuth = {
+  type: 'authorization_code';
+  clientId?: string;
+  clientSecret?: string;
+  scope?: string;
+  callbackPort?: number;
+};
+type OAuthConfig = ClientCredentialsAuth | AuthorizationCodeAuth;
+type HttpServerConfig = {
+  url: string;
+  transport?: 'streamable-http' | 'sse';
+  headers?: Record<string, string>;
+  sessionId?: string;
+  reconnection?: {
+    maxDelay?: number;
+    initialDelay?: number;
+    growFactor?: number;
+    maxRetries?: number;
+  };
+  auth?: OAuthConfig;
+};
+type ServerConfig = StdioServerConfig | HttpServerConfig;
+type DaemonConfig = {
+  idleTimeout?: number;
+  connectTimeout?: number;
+  requestTimeout?: number;
+  healthCheckInterval?: number;
+  maxRestartAttempts?: number;
+  maxTotalTimeout?: number;
+  taskExpiryTimeout?: number;
+  logLevel?: 'debug' | 'info' | 'warn' | 'error';
+  shutdownTimeout?: number;
+  http?: {
+    enabled?: boolean;
+    port?: number;
+    host?: string;
+  };
+};
+type ServerConnectionStatus = 'connecting' | 'connected' | 'error' | 'closed';
+type ServerState = {
+  name: string;
+  config: ServerConfig;
+  status: ServerConnectionStatus;
+  error?: string;
+  serverInfo?: Implementation;
+  capabilities?: ServerCapabilities;
+  protocolVersion?: string;
+  instructions?: string;
+  restartCount?: number;
+  lastHealthCheck?: string;
+  consecutiveFailures?: number;
+};
+//#endregion
+//#region src/client/socket.d.ts
+declare class TooldError extends Error {
+  readonly code: number;
+  readonly data?: unknown;
+  constructor(code: number, message: string, data?: unknown);
+}
+//#endregion
+//#region src/client/index.d.ts
+/** Tool type map – empty by default, populated by `toold typegen`. */
+interface TooldToolMap {}
+type HasTools = keyof TooldToolMap extends never ? false : true;
+type CreateClientOptions = {
+  /** Path to toold.config.json. Uses default resolution if omitted. */configPath?: string; /** Skip auto-starting the daemon. Throws if daemon is not running. Default: true. */
+  autoStart?: boolean;
+};
+type CallOptions = {
+  /** Request timeout in milliseconds. */timeout?: number;
+};
+type CallResult = {
+  content: Array<{
+    type: string;
+    text?: string;
+    mimeType?: string;
+    data?: string;
+    name?: string;
+    uri?: string;
+    resource?: {
+      text?: string;
+      blob?: string;
+      mimeType?: string;
+    };
+  }>;
+  structuredContent?: Record<string, unknown>;
+  isError?: boolean;
+};
+type TaskHandle = {
+  taskId: string;
+  server: string;
+  status: string;
+};
+type DaemonStatus = {
+  pid: number;
+  uptime: number;
+  serverCount: number;
+  servers: ServerState[];
+};
+type ReloadResult = {
+  added: string[];
+  removed: string[];
+  changed: string[];
+};
+type TaskStatus = Record<string, unknown>;
+type TaskResult = Record<string, unknown>;
+type TaskCancelResult = Record<string, unknown>;
+declare class TooldClient {
+  #private;
+  /** @internal Use `createClient()` instead. */
+  constructor(send: (method: string, params?: Record<string, unknown>) => Promise<unknown>);
+  servers(): Promise<ServerState[]>;
+  tools(server?: string): Promise<Array<{
+    server: string;
+    tool: Tool$1;
+  }>>;
+  tool(name: string): Promise<Tool$1>;
+  grep(pattern: string): Promise<Array<{
+    server: string;
+    tool: Tool$1;
+  }>>;
+  call<K extends string>(name: HasTools extends true ? (K extends keyof TooldToolMap ? K : K & {}) : string, args?: K extends keyof TooldToolMap ? TooldToolMap[K]['input'] : Record<string, unknown>, options?: CallOptions): Promise<K extends keyof TooldToolMap ? TooldToolMap[K]['output'] : CallResult>;
+  callAsync(name: string, args?: Record<string, unknown>): Promise<TaskHandle>;
+  resources(server?: string): Promise<Array<{
+    server: string;
+    resource: Resource$1;
+  }>>;
+  read(server: string, uri: string): Promise<ReadResourceResult>;
+  prompts(server?: string): Promise<Array<{
+    server: string;
+    prompt: Prompt$1;
+  }>>;
+  prompt(server: string, name: string, args?: Record<string, string>): Promise<GetPromptResult>;
+  complete(server: string, ref: {
+    type: string;
+    name: string;
+    uri?: string;
+  }, argument: {
+    name: string;
+    value: string;
+  }): Promise<CompleteResult>;
+  tasks(server?: string): Promise<Array<{
+    server: string;
+    tasks: Array<Record<string, unknown>>;
+  }>>;
+  task(server: string, taskId: string): Promise<TaskStatus>;
+  taskResult(server: string, taskId: string): Promise<TaskResult>;
+  taskCancel(server: string, taskId: string): Promise<TaskCancelResult>;
+  status(): Promise<DaemonStatus>;
+  reload(configPath?: string): Promise<ReloadResult>;
+  stop(): Promise<void>;
+  close(): void;
+}
+declare function createClient(options?: CreateClientOptions): Promise<TooldClient>;
+//#endregion
+export { CallOptions, CallResult, CreateClientOptions, type DaemonConfig, DaemonStatus, type HttpServerConfig, type Prompt, ReloadResult, type Resource, type ServerConfig, type ServerState, type StdioServerConfig, TaskCancelResult, TaskHandle, TaskResult, TaskStatus, type Tool, TooldClient, TooldError, TooldToolMap, createClient };

package/dist/client/index.mjs

@@ -0,0 +1,351 @@
+import net from "node:net";
+import { fork } from "node:child_process";
+import fs from "node:fs";
+import path from "node:path";
+import os from "node:os";
+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 ensureTooldDir() {
+	fs.mkdirSync(getTooldDir(), { recursive: true });
+}
+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"));
+			}
+		});
+	});
+}
+var TooldClient = class {
+	#send;
+	constructor(send) {
+		this.#send = send;
+	}
+	async servers() {
+		return await this.#send("servers/list");
+	}
+	async tools(server) {
+		return await this.#send("tools/list", server ? { server } : void 0);
+	}
+	async tool(name) {
+		return await this.#send("tools/info", { name });
+	}
+	async grep(pattern) {
+		return await this.#send("tools/grep", { pattern });
+	}
+	async call(name, args, options) {
+		return await this.#send("tools/call", {
+			name,
+			arguments: args ?? {},
+			...options?.timeout ? { timeout: options.timeout } : {}
+		});
+	}
+	async callAsync(name, args) {
+		return await this.#send("tools/call-async", {
+			name,
+			arguments: args ?? {}
+		});
+	}
+	async resources(server) {
+		return await this.#send("resources/list", server ? { server } : void 0);
+	}
+	async read(server, uri) {
+		return await this.#send("resources/read", {
+			server,
+			uri
+		});
+	}
+	async prompts(server) {
+		return await this.#send("prompts/list", server ? { server } : void 0);
+	}
+	async prompt(server, name, args) {
+		return await this.#send("prompts/get", {
+			server,
+			name,
+			...args ? { arguments: args } : {}
+		});
+	}
+	async complete(server, ref, argument) {
+		return await this.#send("completions/complete", {
+			server,
+			ref,
+			argument
+		});
+	}
+	async tasks(server) {
+		return await this.#send("tasks/list", server ? { server } : void 0);
+	}
+	async task(server, taskId) {
+		return await this.#send("tasks/get", {
+			server,
+			taskId
+		});
+	}
+	async taskResult(server, taskId) {
+		return await this.#send("tasks/result", {
+			server,
+			taskId
+		});
+	}
+	async taskCancel(server, taskId) {
+		return await this.#send("tasks/cancel", {
+			server,
+			taskId
+		});
+	}
+	async status() {
+		return await this.#send("daemon/status");
+	}
+	async reload(configPath) {
+		return await this.#send("config/reload", configPath ? { configPath } : void 0);
+	}
+	async stop() {
+		await this.#send("daemon/stop");
+	}
+	close() {}
+};
+async function createClient(options) {
+	const { configPath, autoStart = true } = options ?? {};
+	if (autoStart) await ensureDaemon(configPath);
+	return new TooldClient(sendRequest);
+}
+export { TooldClient, TooldError, createClient };

package/muxed.generated.d.ts

@@ -0,0 +1,2 @@
+// Stub – run `muxed typegen` to populate with tool types
+export {};

package/package.json

@@ -0,0 +1,78 @@
+{
+  "name": "muxed",
+  "version": "0.1.0",
+  "description": "MCP server daemon and aggregator CLI – aggregate all your Model Context Protocol servers behind a single background daemon with lazy start, auto-reconnect, and idle shutdown",
+  "type": "module",
+  "exports": {
+    ".": {
+      "import": "./dist/client/index.mjs",
+      "types": "./dist/client/index.d.mts"
+    },
+    "./client": {
+      "import": "./dist/client/index.mjs",
+      "types": "./dist/client/index.d.mts"
+    }
+  },
+  "bin": {
+    "muxed": "./bin/cli.mjs"
+  },
+  "files": [
+    "dist",
+    "bin",
+    "muxed.generated.d.ts"
+  ],
+  "engines": {
+    "node": ">=20"
+  },
+  "keywords": [
+    "mcp",
+    "model-context-protocol",
+    "mcp-server",
+    "mcp-proxy",
+    "mcp-aggregator",
+    "mcp-daemon",
+    "mcp-cli",
+    "mcp-tools",
+    "ai-coding",
+    "claude-code",
+    "cursor",
+    "windsurf",
+    "ai-agent",
+    "tool-server",
+    "daemon",
+    "cli"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/skoob13/muxed.git",
+    "directory": "packages/muxed"
+  },
+  "homepage": "https://github.com/skoob13/muxed#readme",
+  "bugs": {
+    "url": "https://github.com/skoob13/muxed/issues"
+  },
+  "author": "Georgiy Tarasov",
+  "license": "MIT",
+  "dependencies": {
+    "@modelcontextprotocol/sdk": "^1.26.0",
+    "commander": "^14.0.0",
+    "json-schema-to-typescript": "^15.0.4",
+    "zod": "^4.3.6"
+  },
+  "devDependencies": {
+    "@modelcontextprotocol/server-everything": "^2026.1.26",
+    "@types/node": "^22.0.0",
+    "obuild": "^0.4.22",
+    "prettier": "^3.8.1",
+    "typescript": "^5.9.3",
+    "vitest": "^4.0.17"
+  },
+  "scripts": {
+    "build": "obuild",
+    "dev": "node src/cli.ts",
+    "format": "prettier --write 'src/**/*.ts'",
+    "format:check": "prettier --check 'src/**/*.ts'",
+    "test": "vitest",
+    "type-check": "tsc --noEmit"
+  }
+}