muxed 0.1.0 → 0.1.1

package/README.md

@@ -0,0 +1,266 @@
+# muxed – MCP Server Daemon & Aggregator CLI
+
+> Aggregate all your [Model Context Protocol](https://modelcontextprotocol.io/) (MCP) servers behind a single daemon. Fewer tokens. Faster execution. Better accuracy.
+
+**muxed** is a background daemon and CLI that sits between your AI agent and your MCP servers. It solves the problems that [Anthropic](https://www.anthropic.com/engineering/code-execution-with-mcp) and [Cloudflare](https://blog.cloudflare.com/code-mode/) have been writing about: tool sprawl eating your context window, slow cold starts, and degraded accuracy as you add more servers.
+
+## The Problem
+
+The MCP ecosystem has a scaling problem. Every tool you connect dumps its full schema into the model's context window. A standard setup with 3-4 MCP servers can consume 20-30% of the context before the agent even starts working. Anthropic's research shows this leads to a 98.7% token overhead on intermediate results. Cloudflare found that agents can't reliably handle more than a handful of servers before tool selection accuracy collapses.
+
+**More tools = worse results.** Every token spent on MCP tool schemas is a token not spent on your actual task – or on the skills, prompts, and default tools that agents execute deterministically.
+
+## How muxed Fixes This
+
+**muxed** is an optimization layer for your MCP infrastructure:
+
+- **Fewer tokens in context** – Tools stay in the daemon, not in the prompt. Agents discover tools on-demand with `muxed grep` and `muxed info` instead of loading every schema upfront. Load only what you need, when you need it.
+- **Faster execution** – Servers stay warm in a background daemon. No cold starts, no repeated connection negotiation. Call tools directly via CLI without round-tripping through the model.
+- **More precise tool selection** – By offloading tool management to muxed, your agent's context window stays clean for what actually matters: reasoning, prompts, and the task at hand. Fewer tools in context means the model picks the right one more often.
+- **Chain calls outside the model** – Pipe tool results through scripts and chain `muxed call` commands in bash without every intermediate result flowing through the LLM. This is the same insight behind Anthropic's code execution approach and Cloudflare's Code Mode – but available today as a simple CLI.
+- **Context engineering wins** – When MCP tools are offloaded to muxed, your context window is freed for skills, prompts, and default tools – the things agents execute deterministically with higher priority. Context engineering beats tool bloat: fewer MCP schemas means your carefully crafted instructions actually get followed.
+
+### For Agents in Production
+
+When you offload MCP tools to muxed, your agents' context windows free up for what actually gets executed reliably: skills, prompts, and default tools. These have deterministic priority – models always follow them. MCP tools, by contrast, compete for attention in a crowded context and get picked less reliably as you add more. By moving tool management out of the model and into a daemon, you're doing context engineering at the infrastructure level – your carefully crafted instructions get followed instead of being drowned out by 30,000 tokens of tool schemas.
+
+## Quick Start
+
+```bash
+# Install globally
+npm install -g muxed
+
+# Or use directly with npx
+npx muxed tools
+
+# List all servers and their status
+muxed servers
+
+# List all available tools across all servers
+muxed tools
+
+# Call a tool
+muxed call filesystem/read_file '{"path": "/tmp/hello.txt"}'
+
+# Search tools by name or description
+muxed grep "search"
+
+# The daemon starts automatically and stops after 5 min idle
+```
+
+## Configuration
+
+Create `muxed.config.json` in your project root (or `~/.config/muxed/config.json` for global config):
+
+```json
+{
+  "mcpServers": {
+    "filesystem": {
+      "command": "npx",
+      "args": ["-y", "@modelcontextprotocol/server-filesystem", "/home/user/projects"],
+      "env": {}
+    },
+    "postgres": {
+      "command": "npx",
+      "args": ["-y", "@modelcontextprotocol/server-postgres"],
+      "env": { "DATABASE_URL": "postgresql://..." }
+    },
+    "remote-api": {
+      "url": "https://mcp.example.com/mcp",
+      "transport": "streamable-http",
+      "headers": { "Authorization": "Bearer ..." }
+    }
+  }
+}
+```
+
+The format is intentionally compatible with the `mcpServers` section of `claude_desktop_config.json` – you can reuse your existing config.
+
+## Architecture
+
+```
+  muxed call server/tool '{}'
+  ──────────────────────────────────►  ┌──────────────────────┐
+  (Unix socket: ~/.muxed/muxed.sock)    │     muxed daemon      │
+                                      │                      │
+  muxed tools                          │  ServerManager(fs)   │──► [stdio: filesystem]
+  ──────────────────────────────────►  │  ServerManager(pg)   │──► [stdio: postgres]
+                                      │  ServerManager(...)   │──► [HTTP: remote]
+  muxed servers                        │                      │
+  ──────────────────────────────────►  └──────────────────────┘
+                                       (auto-exits after idle)
+```
+
+**Lazy start**: The daemon spawns automatically when you run any command. No explicit `muxed start` needed.
+
+**Idle shutdown**: After 5 minutes (configurable) with no requests, the daemon shuts down and cleans up.
+
+## CLI Reference
+
+| Command                                         | Description                                          |
+| ----------------------------------------------- | ---------------------------------------------------- |
+| `muxed servers`                                 | List servers with connection status and capabilities |
+| `muxed tools [server]`                          | List available tools (with annotations)              |
+| `muxed info <server/tool>`                      | Tool schema details (inputSchema, outputSchema)      |
+| `muxed call <server/tool> [json]`               | Invoke a tool                                        |
+| `muxed grep <pattern>`                          | Search tool names, titles, and descriptions          |
+| `muxed resources [server]`                      | List resources                                       |
+| `muxed read <server/resource>`                  | Read a resource                                      |
+| `muxed prompts [server]`                        | List prompt templates                                |
+| `muxed prompt <server/prompt> [args]`           | Render a prompt                                      |
+| `muxed completions <type> <name> <arg> <value>` | Argument auto-completions                            |
+| `muxed tasks [server]`                          | List active tasks                                    |
+| `muxed status`                                  | Daemon status, PID, uptime                           |
+| `muxed reload`                                  | Reload config, reconnect changed servers             |
+| `muxed stop`                                    | Stop daemon manually                                 |
+| `muxed init`                                    | Generate config from discovered MCP servers          |
+
+All commands support `--json` for machine-readable output.
+
+## Node.js API
+
+muxed is also an npm package. Agents can write Node.js scripts that call MCP tools programmatically – with typed results, async/await, and the full npm ecosystem.
+
+```typescript
+import { createClient } from 'muxed';
+
+const client = await createClient();
+
+// Discover tools
+const tools = await client.grep('search');
+
+// Call a tool
+const result = await client.call('filesystem/read_file', {
+  path: '/tmp/config.json',
+});
+
+// Parallel calls across servers
+const [users, tickets] = await Promise.all([
+  client.call('posthog/query-run', { query: { kind: 'HogQLQuery', query: 'SELECT ...' } }),
+  client.call('intercom/search-conversations', { query: 'billing', limit: 10 }),
+]);
+
+// Async tasks for long-running operations
+const task = await client.callAsync('analytics/export', { range: '30d' });
+const status = await client.task(task.server, task.taskId);
+```
+
+Install as a dependency for programmatic use:
+
+```bash
+npm install muxed
+```
+
+The client auto-starts the daemon if it isn't running. Both `import from 'muxed'` and `import from 'muxed/client'` work.
+
+## Use with AI Coding Agents
+
+### Claude Code
+
+Add muxed as a tool source in your Claude Code configuration. The `muxed init` command can auto-discover MCP servers from your `claude_desktop_config.json` and generate an `muxed.config.json`.
+
+### Cursor / Windsurf / Other Agents
+
+Any agent that supports MCP can connect to muxed's daemon via the Unix socket or optional HTTP listener.
+
+## Daemon Settings
+
+```json
+{
+  "daemon": {
+    "idleTimeout": 300000,
+    "connectTimeout": 30000,
+    "requestTimeout": 60000,
+    "http": {
+      "enabled": false,
+      "port": 3100,
+      "host": "127.0.0.1"
+    }
+  }
+}
+```
+
+## Key Features
+
+### Connection Management
+
+- Automatic reconnection with exponential backoff (1s → 60s)
+- Periodic health checks via `ping()`
+- Stale PID/socket detection and cleanup
+
+### Full MCP 2025-11-25 Support
+
+- **Tools** with `title`, `annotations`, `outputSchema`, `structuredContent`
+- **Resources** with text and blob content types
+- **Prompts** with argument rendering
+- **Completions** for argument auto-complete
+- **Tasks** for long-running operations (`--async` flag)
+- **Content types**: text, image, audio, resource links, structured content
+
+### Transport Support
+
+- **stdio** – for local MCP servers (default)
+- **Streamable HTTP** – for remote MCP servers
+- **SSE** – legacy support for older servers
+
+## Replacing mcp-remote
+
+If you're using `mcp-remote` to connect Claude Desktop or ChatGPT to remote MCP servers, muxed is a drop-in upgrade. Instead of adding N separate `mcp-remote` proxy entries to your config, point at one muxed daemon that manages all your remote (and local) servers – with connection pooling, health checks, auto-reconnect, and a CLI for free.
+
+```jsonc
+// Before: mcp-remote in claude_desktop_config.json
+{ "command": "npx", "args": ["mcp-remote", "https://mcp.example.com/sse"] }
+
+// After: muxed.config.json
+{ "url": "https://mcp.example.com/mcp", "transport": "streamable-http" }
+```
+
+## Comparison with Alternatives
+
+| Feature                               | muxed | mcp-remote | mcp-proxy | MetaMCP | 1MCP    |
+| ------------------------------------- | ----- | ---------- | --------- | ------- | ------- |
+| Background daemon                     | ✅    | ❌         | ❌        | ❌      | ❌      |
+| Lazy start / idle shutdown            | ✅    | ❌         | ❌        | ❌      | ❌      |
+| Multi-server aggregation              | ✅    | ❌         | ✅        | ✅      | ✅      |
+| CLI interface                         | ✅    | ❌         | ❌        | ❌      | ✅      |
+| Auto-reconnect / health checks        | ✅    | ❌         | ❌        | ✅      | ✅      |
+| MCP 2025-11-25                        | ✅    | Partial    | Partial   | Partial | Partial |
+| Task support                          | ✅    | ❌         | ❌        | ❌      |
+| Zero config start                     | ✅    | ❌         | ❌        | ❌      |
+| Config compatible with Claude Desktop | ✅    | ❌         | ✅        | ❌      |
+
+## Development
+
+```bash
+# Install dependencies
+pnpm install
+
+# Run in development mode
+pnpm dev
+
+# Build
+pnpm build
+
+# Run tests
+pnpm test
+
+# Type check
+pnpm type-check
+
+# Format
+pnpm format
+```
+
+## Contributing
+
+See [CONTRIBUTING.md](CONTRIBUTING.md) for guidelines.
+
+## License
+
+[MIT](LICENSE) © Georgiy Tarasov
+
+## Links
+
+- [Model Context Protocol Specification](https://modelcontextprotocol.io/)
+- [MCP TypeScript SDK](https://github.com/modelcontextprotocol/typescript-sdk)
+- [Awesome MCP Servers](https://github.com/punkpeye/awesome-mcp-servers)

package/dist/cli.mjs

@@ -84,7 +84,7 @@ const DaemonConfigSchema = z.object({
 	shutdownTimeout: z.number().optional(),
 	http: HttpListenerSchema.optional()
 });
-const TooldConfigSchema = z.object({
+const MuxedConfigSchema = z.object({
 	mcpServers: z.record(z.string(), ServerConfigSchema),
 	daemon: DaemonConfigSchema.optional(),
 	mergeClaudeConfig: z.boolean().optional()
@@ -122,14 +122,14 @@ const DAEMON_DEFAULTS = {
 	shutdownTimeout: 1e4
 };
 function getGlobalConfigPath() {
-	return path.join(os.homedir(), ".config", "toold", "config.json");
+	return path.join(os.homedir(), ".config", "muxed", "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");
+	const cwdConfig = path.join(process.cwd(), "muxed.config.json");
 	if (fs.existsSync(cwdConfig)) return cwdConfig;
 	const homeConfig = getGlobalConfigPath();
 	if (fs.existsSync(homeConfig)) return homeConfig;
@@ -148,7 +148,7 @@ function loadConfig(configPath) {
 	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);
+		const globalResult = MuxedConfigSchema.safeParse(globalRaw);
 		if (globalResult.success) config.mcpServers = {
 			...globalResult.data.mcpServers,
 			...config.mcpServers
@@ -176,7 +176,7 @@ function parseConfigFile(filePath) {
 	} catch {
 		throw new Error(`Invalid JSON in config file: ${filePath}`);
 	}
-	const result = TooldConfigSchema.safeParse(parsed);
+	const result = MuxedConfigSchema.safeParse(parsed);
 	if (!result.success) throw new Error(`Invalid config: ${z.prettifyError(result.error)}`);
 	return result.data;
 }
@@ -187,26 +187,26 @@ function isHttpConfig(config) {
 	return "url" in config;
 }
 var paths_exports = /* @__PURE__ */ __exportAll({
-	ensureTooldDir: () => ensureTooldDir,
+	ensureMuxedDir: () => ensureMuxedDir,
 	getLogPath: () => getLogPath,
+	getMuxedDir: () => getMuxedDir,
 	getPidPath: () => getPidPath,
-	getSocketPath: () => getSocketPath,
-	getTooldDir: () => getTooldDir
+	getSocketPath: () => getSocketPath
 });
-function getTooldDir() {
-	return path.join(os.homedir(), ".toold");
+function getMuxedDir() {
+	return path.join(os.homedir(), ".muxed");
 }
 function getSocketPath() {
-	return path.join(getTooldDir(), "toold.sock");
+	return path.join(getMuxedDir(), "muxed.sock");
 }
 function getPidPath() {
-	return path.join(getTooldDir(), "toold.pid");
+	return path.join(getMuxedDir(), "muxed.pid");
 }
 function getLogPath() {
-	return path.join(getTooldDir(), "toold.log");
+	return path.join(getMuxedDir(), "muxed.log");
 }
-function ensureTooldDir() {
-	fs.mkdirSync(getTooldDir(), { recursive: true });
+function ensureMuxedDir() {
+	fs.mkdirSync(getMuxedDir(), { recursive: true });
 }
 const LOG_LEVELS = {
 	debug: 0,
@@ -296,7 +296,7 @@ function sanitizeName(name) {
 	return name.replace(/[^a-zA-Z0-9_-]/g, "_");
 }
 function getAuthDir() {
-	return path.join(getTooldDir(), "auth");
+	return path.join(getMuxedDir(), "auth");
 }
 function getStorePath(serverName) {
 	return path.join(getAuthDir(), `${sanitizeName(serverName)}.json`);
@@ -388,7 +388,7 @@ var ClientCredentialsProvider = class {
 			token_endpoint_auth_method: "client_secret_basic",
 			grant_types: ["client_credentials"],
 			response_types: [],
-			client_name: "toold"
+			client_name: "muxed"
 		};
 	}
 	clientInformation() {
@@ -443,7 +443,7 @@ function openBrowser(url) {
 	openUrl(url);
 }
 async function notifyReauth(serverName, authUrl) {
-	const title = "toold";
+	const title = "muxed";
 	const message = `Server "${serverName}" needs re-authorization`;
 	const platform = process.platform;
 	if (platform === "darwin") {
@@ -485,7 +485,7 @@ var AuthorizationCodeProvider = class {
 			token_endpoint_auth_method: this.config.clientSecret ? "client_secret_basic" : "none",
 			grant_types: ["authorization_code", "refresh_token"],
 			response_types: ["code"],
-			client_name: "toold",
+			client_name: "muxed",
 			scope: this.config.scope
 		};
 	}
@@ -542,13 +542,13 @@ var AuthorizationCodeProvider = class {
 	}
 };
 const SUCCESS_HTML = `<!DOCTYPE html>
-<html><head><title>toold - Authorization Successful</title></head>
+<html><head><title>muxed - 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>
+<p>You can close this tab and return to muxed.</p>
 </body></html>`;
 const ERROR_HTML = (msg) => `<!DOCTYPE html>
-<html><head><title>toold - Authorization Error</title></head>
+<html><head><title>muxed - Authorization Error</title></head>
 <body style="font-family:system-ui;text-align:center;padding:60px">
 <h1>Authorization Error</h1>
 <p>${msg}</p>
@@ -761,7 +761,7 @@ var ServerManager = class {
 	}
 	createClient() {
 		const client = new Client({
-			name: "toold",
+			name: "muxed",
 			version: "0.1.0"
 		}, {
 			capabilities: { tasks: {
@@ -1318,11 +1318,11 @@ async function generateTypes(tools) {
 		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
+	return `// Auto-generated by \`muxed typegen\` – do not edit
+// Run \`muxed typegen\` to regenerate
 
-declare module 'toold' {
-  interface TooldToolMap {
+declare module 'muxed' {
+  interface MuxedToolMap {
 ${toolTypes.join("\n")}
   }
 }
@@ -1874,8 +1874,8 @@ function createHttpListener(handleRequest, config) {
 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 muxedPkgDir = path.dirname(require.resolve("muxed/package.json"));
+		const outputPath = path.join(muxedPkgDir, "muxed.generated.d.ts");
 		const tools = serverPool.listAllTools();
 		if (tools.length === 0) {
 			logger.debug("No tools available, skipping typegen");
@@ -1885,12 +1885,12 @@ async function runAutoTypegen(serverPool, logger) {
 		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)");
+		logger.debug("Skipping auto-typegen (muxed not resolvable as a dependency)");
 	}
 }
 async function startDaemon(configPath) {
 	const config = loadConfig(configPath);
-	ensureTooldDir();
+	ensureMuxedDir();
 	const isForeground = !!process.send;
 	const logger = initLogger({
 		level: config.daemon?.logLevel ?? "info",
@@ -1946,7 +1946,7 @@ async function startDaemon(configPath) {
 	});
 }
 function getLockPath() {
-	return path.join(getTooldDir(), "toold.lock");
+	return path.join(getMuxedDir(), "muxed.lock");
 }
 function getDaemonPid() {
 	try {
@@ -1965,10 +1965,10 @@ function isProcessAlive(pid) {
 		return false;
 	}
 }
-function isTooldProcess(pid) {
+function isMuxedProcess(pid) {
 	try {
 		const cmdline = fs.readFileSync(`/proc/${pid}/cmdline`, "utf-8");
-		return cmdline.includes("toold") || cmdline.includes("node");
+		return cmdline.includes("muxed") || cmdline.includes("node");
 	} catch {
 		return isProcessAlive(pid);
 	}
@@ -1994,13 +1994,13 @@ function tryConnectSocket(socketPath) {
 function acquireLock() {
 	const lockPath = getLockPath();
 	try {
-		ensureTooldDir();
+		ensureMuxedDir();
 		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)) {
+			if (!Number.isFinite(lockPid) || !isProcessAlive(lockPid) || !isMuxedProcess(lockPid)) {
 				fs.unlinkSync(lockPath);
 				try {
 					fs.writeFileSync(lockPath, String(process.pid), { flag: "wx" });
@@ -2026,7 +2026,7 @@ async function isDaemonRunning() {
 	const pid = getDaemonPid();
 	if (pid === null) return false;
 	if (!isProcessAlive(pid)) return false;
-	if (!isTooldProcess(pid)) return false;
+	if (!isMuxedProcess(pid)) return false;
 	return tryConnectSocket(getSocketPath());
 }
 async function cleanupStaleFiles() {
@@ -2043,7 +2043,7 @@ async function cleanupStaleFiles() {
 		releaseLock();
 		return;
 	}
-	if (pid !== null && isProcessAlive(pid) && !isTooldProcess(pid)) {
+	if (pid !== null && isProcessAlive(pid) && !isMuxedProcess(pid)) {
 		try {
 			fs.unlinkSync(pidPath);
 		} catch {}
@@ -2108,12 +2108,12 @@ async function daemonize(configPath) {
 		releaseLock();
 	}
 }
-var TooldError = class extends Error {
+var MuxedError = class extends Error {
 	code;
 	data;
 	constructor(code, message, data) {
 		super(message);
-		this.name = "TooldError";
+		this.name = "MuxedError";
 		this.code = code;
 		this.data = data;
 	}
@@ -2156,7 +2156,7 @@ async function sendRequest(method, params) {
 		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."));
+			if (err.code === "ENOENT") reject(/* @__PURE__ */ new Error("Daemon is not running. Run `muxed 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);
 		});
@@ -2177,7 +2177,7 @@ async function sendRequest(method, params) {
 			socket.destroy();
 			try {
 				const response = JSON.parse(line);
-				if (response.error) reject(new TooldError(response.error.code, response.error.message, response.error.data));
+				if (response.error) reject(new MuxedError(response.error.code, response.error.message, response.error.data));
 				else resolve(response.result);
 			} catch {
 				reject(/* @__PURE__ */ new Error("Invalid response from daemon"));
@@ -2431,7 +2431,7 @@ function formatInit(result) {
 	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(`Imported ${result.imported.length} server(s) into ${result.muxedConfigPath}:`);
 		lines.push(`  ${result.imported.join(", ")}`);
 	}
 	if (result.skipped.length > 0) {
@@ -2460,7 +2460,7 @@ function formatInit(result) {
 	}
 	if (result.imported.length === 0 && result.skipped.length > 0) {
 		lines.push("");
-		lines.push("All discovered servers already exist in toold config. Nothing to do.");
+		lines.push("All discovered servers already exist in muxed config. Nothing to do.");
 	}
 	return lines.join("\n");
 }
@@ -2637,7 +2637,7 @@ const readCommand = new Command("read").description("Fetch and display the conte
 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();
+const daemonCommand = new Command("daemon").description("Start, stop, reload, or check status of the muxed 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()) {
@@ -2933,7 +2933,7 @@ function getAgentDefs() {
 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`);
+		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 muxed config`);
 	}
 	const url = raw.url ?? raw.serverUrl;
 	const command = raw.command;
@@ -2978,7 +2978,7 @@ function discoverAgentConfigs() {
 		const servers = {};
 		for (const [name, raw] of Object.entries(rawServers)) {
 			if (typeof raw !== "object" || raw === null) continue;
-			if (name === "toold") continue;
+			if (name === "muxed") continue;
 			const normalized = normalizeServer(agent, name, raw, warnings);
 			if (normalized) servers[name] = normalized;
 		}
@@ -3033,7 +3033,7 @@ function mergeServers(discovered, existingServers) {
 function detectIndent(text) {
 	return text.match(/^(\s+)"/m)?.[1] ?? "  ";
 }
-function writeTooldConfig(configPath, servers) {
+function writeMuxedConfig(configPath, servers) {
 	let existing = {};
 	if (fs.existsSync(configPath)) try {
 		existing = JSON.parse(fs.readFileSync(configPath, "utf-8"));
@@ -3043,15 +3043,15 @@ function writeTooldConfig(configPath, servers) {
 	existing.mcpServers = servers;
 	fs.writeFileSync(configPath, JSON.stringify(existing, null, 2) + "\n");
 }
-function getTooldEntry(agent) {
+function getMuxedEntry(agent) {
 	if (agent.serversKey === "servers") return {
 		type: "stdio",
 		command: "npx",
-		args: ["toold@latest", "proxy"]
+		args: ["muxed@latest", "proxy"]
 	};
 	return {
 		command: "npx",
-		args: ["toold@latest", "proxy"]
+		args: ["muxed@latest", "proxy"]
 	};
 }
 function modifyAgentConfig(dc, opts) {
@@ -3059,14 +3059,14 @@ function modifyAgentConfig(dc, opts) {
 	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) };
+	if (opts.delete) if (opts.replace) content[dc.agent.serversKey] = { muxed: getMuxedEntry(dc.agent) };
 	else delete content[dc.agent.serversKey];
 	fs.writeFileSync(dc.configPath, JSON.stringify(content, null, indent) + "\n");
 }
-function getTooldConfigPath(scope, explicitPath) {
+function getMuxedConfigPath(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");
+	if (scope === "local") return path.join(process.cwd(), "muxed.config.json");
+	return path.join(home, ".config", "muxed", "config.json");
 }
 async function confirm(message, opts) {
 	const rl = readline.createInterface({
@@ -3135,7 +3135,7 @@ async function resolveConflicts(unresolvedConflicts, isInteractive) {
 		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 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 muxed 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();
@@ -3144,10 +3144,10 @@ const initCommand = new Command("init").description("Discover and import MCP ser
 		console.log(opts.json ? formatJson({ message: msg }) : msg);
 		return;
 	}
-	const tooldPath = getTooldConfigPath(discovered.some((d) => d.agent.scope === "local") ? "local" : "global", configPath);
+	const muxedPath = getMuxedConfigPath(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 ?? {};
+	if (fs.existsSync(muxedPath)) try {
+		existingServers = JSON.parse(fs.readFileSync(muxedPath, "utf-8")).mcpServers ?? {};
 	} catch {}
 	const result = mergeServers(discovered, existingServers);
 	const { resolved, conflicts } = await resolveConflicts(result.unresolvedConflicts, isInteractive);
@@ -3156,7 +3156,7 @@ const initCommand = new Command("init").description("Discover and import MCP ser
 		result.merged[name] = config;
 		imported.push(name);
 	}
-	if (!opts.dryRun && imported.length > 0) writeTooldConfig(tooldPath, result.merged);
+	if (!opts.dryRun && imported.length > 0) writeMuxedConfig(muxedPath, 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 {
@@ -3180,13 +3180,13 @@ const initCommand = new Command("init").description("Discover and import MCP ser
 		conflicts,
 		warnings,
 		modifiedFiles,
-		tooldConfigPath: tooldPath,
+		muxedConfigPath: muxedPath,
 		dryRun: opts.dryRun ?? false
 	};
 	console.log(opts.json ? formatJson(initResult) : formatInit(initResult));
 });
 function getConfigPath(scope, explicitPath) {
-	return getTooldConfigPath(scope, explicitPath);
+	return getMuxedConfigPath(scope, explicitPath);
 }
 function readConfigFile(filePath) {
 	if (!fs.existsSync(filePath)) return { mcpServers: {} };
@@ -3235,17 +3235,17 @@ 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.
+You have access to an \`npx muxed\` 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>'.
+1. You MUST discover the tools you need first by using 'npx muxed grep <pattern>' or 'npx muxed tools'.
+2. You MUST call 'npx muxed info <server>/<tool>' BEFORE ANY 'npx muxed 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.
+**NEVER** make an npx muxed call without checking the schema first.
+**ALWAYS** run npx muxed 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
@@ -3254,7 +3254,7 @@ These are BLOCKING REQUIREMENTS - like how you must use Read before Edit.
 - 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.
+**For multiple tools:** Call 'npx muxed info' for ALL tools in parallel FIRST, then make your 'npx muxed call' commands.
 
 Available MCP servers:
 ${servers}
@@ -3262,98 +3262,98 @@ ${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)
+npx muxed grep <pattern>                 # Search tool names and descriptions
+npx muxed 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
+npx muxed 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)
+npx muxed call <server>/<tool> '<json>'  # Only run AFTER npx muxed info
+npx muxed call <server>/<tool> -         # Invoke with JSON from stdin (AFTER npx muxed 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
+npx muxed servers                        # List all connected MCP servers
+npx muxed tools [server]                 # List available tools (optionally filter by server)
+npx muxed grep <pattern>                 # Search tool names and descriptions
+npx muxed resources [server]             # List MCP resources
+npx muxed 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: As a first step, I need to discover the tools I need. Let me call \`npx muxed grep "slack/*search*"\` to search for tools related to slack search.
+[Calls npx muxed grep "slack/*search*"]
+Assistant: I need to check the schema first. Let me call \`npx muxed info slack/search_private\` to see what parameters it accepts.
+[Calls npx muxed 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]
+[Calls npx muxed 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: I'll need to use two MCP tools. Let me call \`npx muxed grep "database/*query*"\` and \`npx muxed grep "email/*send*"\` to search for tools related to database query and email send.
+[Calls npx muxed grep "database/*query*" & npx muxed grep "email/*send*"]
 Assistant: Let me check both schemas first.
-[Calls npx toold info database/query and npx toold info email/send in parallel]
+[Calls npx muxed info database/query and npx muxed 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]
+[Makes both npx muxed 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.]
+[Calls npx muxed grep "email/*copy*". No results found.]
 Assistant: Let me try another pattern.
-[Calls npx toold grep "email/*clone*". No results found.]
+[Calls npx muxed grep "email/*clone*". No results found.]
 Assistant: Let me list all available tools in the server.
-[Calls npx toold tools email]
+[Calls npx muxed tools email]
 Assistant: Let me check the schema first.
-[Calls npx toold info email/duplicate]
+[Calls npx muxed info email/duplicate]
 Assistant: Now I have the schema. Let me make the call.
-[Calls npx toold call email/duplicate with correct parameters]
+[Calls npx muxed 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
+Assistant: [Directly calls npx muxed call slack/search_private with guessed parameters]
+WRONG - You must call npx muxed 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.
+[Calls npx muxed call slack/search_private directly]
+WRONG - Pre-approved permissions don't mean you know the schema. ALWAYS call npx muxed 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
+Assistant: [Calls three npx muxed call commands in parallel without any npx muxed info calls first]
+WRONG - You must call npx muxed info for ALL tools before making ANY npx muxed 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
+npx muxed tools                          # See all available MCP tools
+npx muxed grep "weather"                 # Find tools by description
 
 # Get tool details
-npx toold info <server>/<tool>           # View JSON schema for input and output if available
+npx muxed info <server>/<tool>           # View JSON schema for input and output if available
 
 # Simple tool call (no parameters)
-npx toold call weather/get_location '{}'
+npx muxed call weather/get_location '{}'
 
 # Tool call with parameters
-npx toold call database/query '{"table": "users", "limit": 10}'
+npx muxed call database/query '{"table": "users", "limit": 10}'
 
 # Complex JSON using stdin (for nested objects/arrays)
-npx toold call api/send_request - <<'EOF'
+npx muxed call api/send_request - <<'EOF'
 {
   "endpoint": "/data",
   "headers": {"Authorization": "Bearer token"},
@@ -3362,9 +3362,9 @@ npx toold call api/send_request - <<'EOF'
 EOF
 \`\`\`
 
-Call the \`npx toold -h\` to see all available commands.
+Call the \`npx muxed -h\` to see all available commands.
 
-Below are the instructions for the connected MCP servers in toold.
+Below are the instructions for the connected MCP servers in muxed.
 
 ${instructions}
 `;
@@ -3375,7 +3375,7 @@ function buildInstructions(servers) {
 async function startMcpProxy(configPath) {
 	await ensureDaemon(configPath);
 	const server = new McpServer({
-		name: "toold",
+		name: "muxed",
 		version: "0.1.0"
 	}, {
 		capabilities: {},
@@ -3529,7 +3529,7 @@ mcpCommand.command("add-from-claude-desktop").description("Import MCP servers fr
 		existingServers = JSON.parse(fs.readFileSync(configPath, "utf-8")).mcpServers ?? {};
 	} catch {}
 	const result = mergeServers(claudeDesktop, existingServers);
-	writeTooldConfig(configPath, { ...result.merged });
+	writeMuxedConfig(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(", ")}`);
@@ -3608,19 +3608,19 @@ mcpCommand.command("remove").description("Remove an MCP server").argument("<name
 	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) => {
+const typegenCommand = new Command("typegen").description("Generate TypeScript types from tool schemas for type-safe tool calls").option("-c, --config <path>", "Path to muxed.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");
+	const muxedPkgDir = path.dirname(require.resolve("muxed/package.json"));
+	const outputPath = path.join(muxedPkgDir, "muxed.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.name("muxed").description("The optimization layer for MCP").version("0.1.0");
 	program.enablePositionalOptions();
 	program.option("--config <path>", "Path to config file");
 	program.commandsGroup("Servers:");

package/dist/client/index.d.mts

@@ -67,18 +67,18 @@ type ServerState = {
 };
 //#endregion
 //#region src/client/socket.d.ts
-declare class TooldError extends Error {
+declare class MuxedError 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;
+/** Tool type map – empty by default, populated by `muxed typegen`. */
+interface MuxedToolMap {}
+type HasTools = keyof MuxedToolMap 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. */
+  /** Path to muxed.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 = {
@@ -120,7 +120,7 @@ type ReloadResult = {
 type TaskStatus = Record<string, unknown>;
 type TaskResult = Record<string, unknown>;
 type TaskCancelResult = Record<string, unknown>;
-declare class TooldClient {
+declare class MuxedClient {
   #private;
   /** @internal Use `createClient()` instead. */
   constructor(send: (method: string, params?: Record<string, unknown>) => Promise<unknown>);
@@ -134,7 +134,7 @@ declare class TooldClient {
     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>;
+  call<K extends string>(name: HasTools extends true ? (K extends keyof MuxedToolMap ? K : K & {}) : string, args?: K extends keyof MuxedToolMap ? MuxedToolMap[K]['input'] : Record<string, unknown>, options?: CallOptions): Promise<K extends keyof MuxedToolMap ? MuxedToolMap[K]['output'] : CallResult>;
   callAsync(name: string, args?: Record<string, unknown>): Promise<TaskHandle>;
   resources(server?: string): Promise<Array<{
     server: string;
@@ -166,6 +166,6 @@ declare class TooldClient {
   stop(): Promise<void>;
   close(): void;
 }
-declare function createClient(options?: CreateClientOptions): Promise<TooldClient>;
+declare function createClient(options?: CreateClientOptions): Promise<MuxedClient>;
 //#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 };
+export { CallOptions, CallResult, CreateClientOptions, type DaemonConfig, DaemonStatus, type HttpServerConfig, MuxedClient, MuxedError, MuxedToolMap, type Prompt, ReloadResult, type Resource, type ServerConfig, type ServerState, type StdioServerConfig, TaskCancelResult, TaskHandle, TaskResult, TaskStatus, type Tool, createClient };

package/dist/client/index.mjs

@@ -3,20 +3,20 @@ 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 getMuxedDir() {
+	return path.join(os.homedir(), ".muxed");
 }
 function getSocketPath() {
-	return path.join(getTooldDir(), "toold.sock");
+	return path.join(getMuxedDir(), "muxed.sock");
 }
 function getPidPath() {
-	return path.join(getTooldDir(), "toold.pid");
+	return path.join(getMuxedDir(), "muxed.pid");
 }
-function ensureTooldDir() {
-	fs.mkdirSync(getTooldDir(), { recursive: true });
+function ensureMuxedDir() {
+	fs.mkdirSync(getMuxedDir(), { recursive: true });
 }
 function getLockPath() {
-	return path.join(getTooldDir(), "toold.lock");
+	return path.join(getMuxedDir(), "muxed.lock");
 }
 function getDaemonPid() {
 	try {
@@ -35,10 +35,10 @@ function isProcessAlive(pid) {
 		return false;
 	}
 }
-function isTooldProcess(pid) {
+function isMuxedProcess(pid) {
 	try {
 		const cmdline = fs.readFileSync(`/proc/${pid}/cmdline`, "utf-8");
-		return cmdline.includes("toold") || cmdline.includes("node");
+		return cmdline.includes("muxed") || cmdline.includes("node");
 	} catch {
 		return isProcessAlive(pid);
 	}
@@ -64,13 +64,13 @@ function tryConnectSocket(socketPath) {
 function acquireLock() {
 	const lockPath = getLockPath();
 	try {
-		ensureTooldDir();
+		ensureMuxedDir();
 		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)) {
+			if (!Number.isFinite(lockPid) || !isProcessAlive(lockPid) || !isMuxedProcess(lockPid)) {
 				fs.unlinkSync(lockPath);
 				try {
 					fs.writeFileSync(lockPath, String(process.pid), { flag: "wx" });
@@ -96,7 +96,7 @@ async function isDaemonRunning() {
 	const pid = getDaemonPid();
 	if (pid === null) return false;
 	if (!isProcessAlive(pid)) return false;
-	if (!isTooldProcess(pid)) return false;
+	if (!isMuxedProcess(pid)) return false;
 	return tryConnectSocket(getSocketPath());
 }
 async function cleanupStaleFiles() {
@@ -113,7 +113,7 @@ async function cleanupStaleFiles() {
 		releaseLock();
 		return;
 	}
-	if (pid !== null && isProcessAlive(pid) && !isTooldProcess(pid)) {
+	if (pid !== null && isProcessAlive(pid) && !isMuxedProcess(pid)) {
 		try {
 			fs.unlinkSync(pidPath);
 		} catch {}
@@ -178,12 +178,12 @@ async function daemonize(configPath) {
 		releaseLock();
 	}
 }
-var TooldError = class extends Error {
+var MuxedError = class extends Error {
 	code;
 	data;
 	constructor(code, message, data) {
 		super(message);
-		this.name = "TooldError";
+		this.name = "MuxedError";
 		this.code = code;
 		this.data = data;
 	}
@@ -226,7 +226,7 @@ async function sendRequest(method, params) {
 		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."));
+			if (err.code === "ENOENT") reject(/* @__PURE__ */ new Error("Daemon is not running. Run `muxed 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);
 		});
@@ -247,7 +247,7 @@ async function sendRequest(method, params) {
 			socket.destroy();
 			try {
 				const response = JSON.parse(line);
-				if (response.error) reject(new TooldError(response.error.code, response.error.message, response.error.data));
+				if (response.error) reject(new MuxedError(response.error.code, response.error.message, response.error.data));
 				else resolve(response.result);
 			} catch {
 				reject(/* @__PURE__ */ new Error("Invalid response from daemon"));
@@ -255,7 +255,7 @@ async function sendRequest(method, params) {
 		});
 	});
 }
-var TooldClient = class {
+var MuxedClient = class {
 	#send;
 	constructor(send) {
 		this.#send = send;
@@ -346,6 +346,6 @@ var TooldClient = class {
 async function createClient(options) {
 	const { configPath, autoStart = true } = options ?? {};
 	if (autoStart) await ensureDaemon(configPath);
-	return new TooldClient(sendRequest);
+	return new MuxedClient(sendRequest);
 }
-export { TooldClient, TooldError, createClient };
+export { MuxedClient, MuxedError, createClient };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "muxed",
-  "version": "0.1.0",
+  "version": "0.1.1",
   "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": {
@@ -19,7 +19,8 @@
   "files": [
     "dist",
     "bin",
-    "muxed.generated.d.ts"
+    "muxed.generated.d.ts",
+    "README.md"
   ],
   "engines": {
     "node": ">=20"
@@ -53,6 +54,15 @@
   },
   "author": "Georgiy Tarasov",
   "license": "MIT",
+  "scripts": {
+    "build": "obuild",
+    "dev": "node src/cli.ts",
+    "format": "prettier --write 'src/**/*.ts'",
+    "format:check": "prettier --check 'src/**/*.ts'",
+    "publish": "tsc --noEmit && prettier --check 'src/**/*.ts' && pnpm build && cp ../../README.md . && npm publish",
+    "test": "vitest",
+    "type-check": "tsc --noEmit"
+  },
   "dependencies": {
     "@modelcontextprotocol/sdk": "^1.26.0",
     "commander": "^14.0.0",
@@ -66,13 +76,5 @@
     "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"
   }
-}
+}

package/LICENSE

@@ -1,21 +0,0 @@
-MIT License
-
-Copyright (c) 2026 Georgiy Tarasov
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in all
-copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-SOFTWARE.