@luutuankiet/mcp-proxy-shim 1.1.1 → 1.1.3

package/dist/daemon.js

@@ -1,426 +1,395 @@
 #!/usr/bin/env node
 /**
- * MCP Proxy Shim — Daemon Mode
+ * MCP Proxy Shim — Daemon Mode (REST + MCP Gateway)
  *
- * Multi-server MCP gateway: connects to N upstream MCP servers (stdio or HTTP)
- * and exposes all their tools through a single HTTP Streamable endpoint.
- *
- * Pure passthrough — no schema transformation. Designed for cloud agents that
- * can't spawn MCP servers on the fly.
+ * Connects to a single upstream mcpproxy-go via MCP_URL (same as stdio/serve modes)
+ * and exposes both REST endpoints for curl-based subagents AND a Streamable HTTP
+ * /mcp endpoint for backward compatibility.
  *
  * Architecture:
- *   Cloud Agent ──HTTP──▶ daemon (:3456) ──┬── stdio ──▶ spawned process
- *                                          ├── HTTP  ──▶ remote MCP server
- *                                          └── stdio ──▶ another process
+ *   Subagent ──curl──▶ daemon (:3456) ──HTTP──▶ mcpproxy-go (upstream)
+ *   MCP client ──HTTP──▶ daemon (:3456/mcp) ──HTTP──▶ mcpproxy-go (upstream)
  *
- * Configuration via MCP_SERVERS env var (JSON) or MCP_CONFIG file path:
+ * REST endpoints (clean JSON, no MCP wrappers):
+ *   GET  /health           Health check + session info
+ *   POST /retrieve_tools   { query, compact?, limit? }
+ *   POST /describe_tools   { names: [...] }
+ *   POST /call             { method, name, args, reason?, sensitivity? }
+ *   POST /exec             { code }
+ *   POST /reinit           Force new upstream session
  *
- *   {
- *     "github": {
- *       "type": "stdio",
- *       "command": "npx",
- *       "args": ["-y", "@modelcontextprotocol/server-github"],
- *       "env": { "GITHUB_TOKEN": "ghp_..." }
- *     },
- *     "my-api": {
- *       "type": "streamableHttp",
- *       "url": "https://api.example.com/mcp",
- *       "headers": { "Authorization": "Bearer xxx", "X-Custom": "value" }
- *     }
- *   }
+ * MCP endpoint (Streamable HTTP, backward compat):
+ *   POST/GET/DELETE /mcp   Standard MCP Streamable HTTP protocol
  *
  * Environment variables:
- *   MCP_SERVERS    JSON string with server configs (inline)
- *   MCP_CONFIG     Path to JSON config file (alternative to MCP_SERVERS)
- *   MCP_PORT       Port to listen on (default: 3456)
- *   MCP_HOST       Host to bind to (default: 0.0.0.0)
- *   MCP_APIKEY     Require ?apikey=KEY on /mcp requests (optional)
+ *   MCP_URL      (required)  Upstream mcpproxy-go StreamableHTTP endpoint
+ *   MCP_PORT     (optional)  Port to listen on (default: 3456)
+ *   MCP_HOST     (optional)  Host to bind to (default: 0.0.0.0)
+ *   MCP_APIKEY   (optional)  Require ?apikey=KEY on requests
+ *   https_proxy  (optional)  HTTPS proxy for upstream connection
  *
  * Usage:
- *   MCP_SERVERS='{"github":{"type":"stdio","command":"npx","args":["-y","@modelcontextprotocol/server-github"]}}' \
- *     npx @luutuankiet/mcp-proxy-shim daemon
- *
- *   MCP_CONFIG=./mcp-servers.json npx @luutuankiet/mcp-proxy-shim daemon
+ *   MCP_URL="https://proxy.example.com/mcp/?apikey=KEY" npx @luutuankiet/mcp-proxy-shim daemon
  */
-import { readFileSync } from "node:fs";
+import { readFileSync, existsSync } from "node:fs";
+import { join } from "node:path";
 import { randomUUID } from "node:crypto";
 import http from "node:http";
-import { Client } from "@modelcontextprotocol/sdk/client/index.js";
-import { StdioClientTransport } from "@modelcontextprotocol/sdk/client/stdio.js";
-import { StreamableHTTPClientTransport } from "@modelcontextprotocol/sdk/client/streamableHttp.js";
-import { Server } from "@modelcontextprotocol/sdk/server/index.js";
 import { StreamableHTTPServerTransport } from "@modelcontextprotocol/sdk/server/streamableHttp.js";
-import { ListToolsRequestSchema, CallToolRequestSchema, isInitializeRequest, } from "@modelcontextprotocol/sdk/types.js";
-// Proxy support — same pattern as core.ts
-import { createRequire } from "node:module";
-const _require = createRequire(import.meta.url);
-const { ProxyAgent } = _require("undici");
-const PROXY_URL = process.env.https_proxy || process.env.HTTPS_PROXY || "";
-const proxyDispatcher = PROXY_URL ? new ProxyAgent(PROXY_URL) : undefined;
+import { isInitializeRequest } from "@modelcontextprotocol/sdk/types.js";
+import { createShimServer, log, maskUrl, UPSTREAM_URL, ensureSession, mcpRequest, deepUnwrapResult, compactRetrieveTools, transformToolCallArgs, reinitOnExpiry, getSessionId, resetSessionId, } from "./core.js";
+// ---------------------------------------------------------------------------
+// Auto-load .cloud.env from CWD if MCP_URL not in environment
+// ---------------------------------------------------------------------------
+function autoLoadCloudEnv() {
+    if (process.env.MCP_URL)
+        return;
+    const envPath = join(process.cwd(), ".cloud.env");
+    if (!existsSync(envPath))
+        return;
+    try {
+        const content = readFileSync(envPath, "utf-8");
+        for (const line of content.split("\n")) {
+            const trimmed = line.trim();
+            if (!trimmed || trimmed.startsWith("#"))
+                continue;
+            const eqIdx = trimmed.indexOf("=");
+            if (eqIdx < 1)
+                continue;
+            const key = trimmed.slice(0, eqIdx).trim();
+            let val = trimmed.slice(eqIdx + 1).trim();
+            if ((val.startsWith('"') && val.endsWith('"')) || (val.startsWith("'") && val.endsWith("'"))) {
+                val = val.slice(1, -1);
+            }
+            if (!process.env[key]) {
+                process.env[key] = val;
+            }
+        }
+        log("Loaded environment from .cloud.env");
+    }
+    catch (err) {
+        log("Warning: failed to load .cloud.env:", err.message);
+    }
+}
 // ---------------------------------------------------------------------------
 // Config
 // ---------------------------------------------------------------------------
 const PORT = parseInt(process.env.MCP_PORT || "3456", 10);
 const HOST = process.env.MCP_HOST || "0.0.0.0";
 const APIKEY = process.env.MCP_APIKEY || null;
-function log(...args) {
-    console.error("[mcp-daemon]", ...args);
-}
-function loadConfig() {
-    // Try inline JSON first
-    if (process.env.MCP_SERVERS) {
-        try {
-            return JSON.parse(process.env.MCP_SERVERS);
-        }
-        catch (err) {
-            log("Fatal: MCP_SERVERS is not valid JSON:", err.message);
-            process.exit(1);
-        }
-    }
-    // Try config file
-    if (process.env.MCP_CONFIG) {
-        try {
-            const raw = readFileSync(process.env.MCP_CONFIG, "utf-8");
-            const parsed = JSON.parse(raw);
-            // Support both { servers: {...} } and flat { name: config } format
-            // Also support .mcp.json format: { mcpServers: {...} }
-            return parsed.mcpServers || parsed.servers || parsed;
-        }
-        catch (err) {
-            log("Fatal: Cannot read MCP_CONFIG:", err.message);
-            process.exit(1);
-        }
-    }
-    log("Fatal: No server configuration provided.");
-    log("Set MCP_SERVERS (JSON) or MCP_CONFIG (file path).");
-    log("");
-    log("Example:");
-    log(`  MCP_SERVERS='{"my-server":{"type":"stdio","command":"npx","args":["-y","some-mcp-server"]}}' \\`);
-    log("    npx @luutuankiet/mcp-proxy-shim daemon");
-    process.exit(1);
-    return {};
+const startTime = Date.now();
+let callCount = 0;
+// ---------------------------------------------------------------------------
+// JSON body parser
+// ---------------------------------------------------------------------------
+function parseBody(req) {
+    return new Promise((resolve) => {
+        const chunks = [];
+        req.on("data", (chunk) => chunks.push(chunk));
+        req.on("end", () => {
+            try {
+                const raw = Buffer.concat(chunks).toString("utf-8");
+                resolve(raw ? JSON.parse(raw) : {});
+            }
+            catch {
+                resolve({});
+            }
+        });
+        req.on("error", () => resolve({}));
+    });
 }
 // ---------------------------------------------------------------------------
-// Upstream connection management
+// REST response helpers
 // ---------------------------------------------------------------------------
-const upstreams = new Map();
-/** Namespace a tool name with server prefix to avoid collisions */
-function namespaceTool(serverName, toolName) {
-    return `${serverName}__${toolName}`;
+function jsonResponse(res, status, body) {
+    res.writeHead(status, {
+        "Content-Type": "application/json",
+        "Access-Control-Allow-Origin": "*",
+    });
+    res.end(JSON.stringify(body));
 }
-/** Extract server name and original tool name from namespaced name */
-function parseNamespacedTool(namespacedName) {
-    for (const [name] of upstreams) {
-        const prefix = `${name}__`;
-        if (namespacedName.startsWith(prefix)) {
-            return { serverName: name, toolName: namespacedName.slice(prefix.length) };
-        }
-    }
-    return null;
+/**
+ * Unwrap an MCP tools/call response to clean JSON for REST consumers.
+ * Parses content[0].text and JSON.parse if possible.
+ */
+function unwrapForRest(result) {
+    return deepUnwrapResult(result);
 }
-async function connectStdio(name, config) {
-    log(`[${name}] Connecting via stdio: ${config.command} ${(config.args || []).join(" ")}`);
-    const client = new Client({ name: `mcp-daemon/${name}`, version: "1.0.0" }, { capabilities: {} });
-    const transport = new StdioClientTransport({
-        command: config.command,
-        args: config.args,
-        env: { ...process.env, ...(config.env || {}) },
-        cwd: config.cwd,
+// ---------------------------------------------------------------------------
+// REST endpoint handlers
+// ---------------------------------------------------------------------------
+async function handleHealth(_req, res) {
+    const sid = getSessionId();
+    jsonResponse(res, 200, {
+        ok: !!sid,
+        sessionId: sid ? sid.slice(0, 12) + "..." : null,
+        uptime: Math.round((Date.now() - startTime) / 1000),
+        callCount,
     });
-    await client.connect(transport);
-    log(`[${name}] Connected (pid: ${transport.pid ?? "unknown"})`);
-    // Fetch tools
-    const toolsResult = await client.listTools();
-    const tools = (toolsResult.tools || []);
-    log(`[${name}] ${tools.length} tools available`);
-    return { name, config, client, tools, connected: true };
 }
-async function connectHttp(name, config) {
-    const maskedUrl = config.url.replace(/apikey=[^&\s]+/gi, "apikey=***");
-    log(`[${name}] Connecting via HTTP: ${maskedUrl}`);
-    if (config.headers) {
-        const headerNames = Object.keys(config.headers);
-        log(`[${name}] Custom headers: ${headerNames.join(", ")}`);
-    }
-    const client = new Client({ name: `mcp-daemon/${name}`, version: "1.0.0" }, { capabilities: {} });
-    const url = new URL(config.url);
-    // Build requestInit with custom headers and proxy support
-    const requestInit = {};
-    if (config.headers && Object.keys(config.headers).length > 0) {
-        requestInit.headers = config.headers;
+async function handleRetrieveTools(req, res) {
+    const body = await parseBody(req);
+    const query = body.query;
+    if (!query) {
+        return jsonResponse(res, 400, { error: "query is required" });
     }
-    if (proxyDispatcher) {
-        requestInit.dispatcher = proxyDispatcher;
-        log(`[${name}] Using HTTPS proxy`);
+    try {
+        await ensureSession();
+        callCount++;
+        const resp = await mcpRequest("tools/call", {
+            name: "retrieve_tools",
+            arguments: body,
+        });
+        if (!resp || resp.error) {
+            return jsonResponse(res, 502, {
+                error: "upstream error",
+                detail: resp?.error || "no response",
+            });
+        }
+        const compacted = compactRetrieveTools(deepUnwrapResult(resp.result), body);
+        const unwrapped = unwrapForRest(compacted);
+        return jsonResponse(res, 200, unwrapped);
     }
-    const opts = {};
-    if (Object.keys(requestInit).length > 0) {
-        opts.requestInit = requestInit;
+    catch (err) {
+        return jsonResponse(res, 500, { error: err.message });
     }
-    const transport = new StreamableHTTPClientTransport(url, opts);
-    await client.connect(transport);
-    log(`[${name}] Connected`);
-    // Fetch tools
-    const toolsResult = await client.listTools();
-    const tools = (toolsResult.tools || []);
-    log(`[${name}] ${tools.length} tools available`);
-    return { name, config, client, tools, connected: true };
 }
-async function connectServer(name, config) {
+/**
+ * describe_tools — batch-hydrate tool schemas.
+ *
+ * Strategy (mirrors core.ts shim-local describe_tools):
+ * 1. Derive multiple BM25 search queries from each requested name
+ * 2. Query upstream retrieve_tools for each (gets FULL schemas, not compacted)
+ * 3. Build an index keyed by raw name + server:name composite
+ * 4. Resolve each requested name with flexible matching
+ */
+async function handleDescribeTools(req, res) {
+    const body = await parseBody(req);
+    const names = body.names;
+    if (!Array.isArray(names) || names.length === 0) {
+        return jsonResponse(res, 400, { error: "names array is required" });
+    }
     try {
-        if (config.type === "stdio") {
-            return await connectStdio(name, config);
-        }
-        else if (config.type === "streamableHttp" || config.type === "http" || config.type === "sse") {
-            return await connectHttp(name, config);
+        await ensureSession();
+        callCount++;
+        // 1. Derive search queries from tool names (same strategy as core.ts)
+        const queries = new Set();
+        for (const n of names) {
+            const raw = n.includes(":") ? n.split(":").slice(1).join(":") : n;
+            // Raw name as-is — BM25 often matches exact tool names well
+            queries.add(raw);
+            // Full name with separators → spaces
+            queries.add(raw.replace(/__/g, " ").replace(/[-_]/g, " "));
+            // Segment-based queries for compound names
+            const parts = raw.split("__");
+            if (parts.length > 1) {
+                const toolPart = parts[parts.length - 1] || raw;
+                queries.add(toolPart.replace(/[-_]/g, " "));
+                const prefixPart = parts[0];
+                if (prefixPart && prefixPart !== toolPart) {
+                    queries.add(prefixPart.replace(/[-_]/g, " ") + " " + toolPart.replace(/[-_]/g, " "));
+                }
+            }
         }
-        else {
-            log(`[${name}] Unknown server type: ${config.type}`);
-            return null;
+        // 2. Query upstream retrieve_tools for each (full schemas, no compaction)
+        const index = new Map();
+        for (const query of queries) {
+            try {
+                const resp = await mcpRequest("tools/call", {
+                    name: "retrieve_tools",
+                    arguments: { query },
+                });
+                if (resp?.result) {
+                    const unwrapped = deepUnwrapResult(resp.result);
+                    const tools = Array.isArray(unwrapped)
+                        ? unwrapped
+                        : (Array.isArray(unwrapped?.tools) ? unwrapped.tools : []);
+                    for (const t of tools) {
+                        const tool = t;
+                        const tName = tool.name;
+                        if (tName && !index.has(tName)) {
+                            index.set(tName, tool);
+                        }
+                        // Also key by server:name composite for flexible lookup
+                        if (tool.server) {
+                            const composite = `${tool.server}:${tName}`;
+                            if (!index.has(composite))
+                                index.set(composite, tool);
+                        }
+                    }
+                }
+            }
+            catch (err) {
+                log("describe_tools query failed:", query, err.message);
+            }
         }
+        // 3. Resolve each requested name with flexible matching
+        const results = names.map((n) => {
+            // Exact match
+            let tool = index.get(n);
+            if (tool)
+                return tool;
+            // Without server: prefix (e.g., "utils:read_files" → "read_files")
+            if (n.includes(":")) {
+                const withoutPrefix = n.split(":").slice(1).join(":");
+                tool = index.get(withoutPrefix);
+                if (tool)
+                    return tool;
+            }
+            // Suffix/prefix match
+            for (const [key, candidate] of index) {
+                if (key.endsWith(n) || n.endsWith(key))
+                    return candidate;
+            }
+            // Fuzzy suffix match — handle mount-path variations
+            const nParts = n.includes(":") ? n.split(":").slice(1).join(":").split("__") : n.split("__");
+            const nSuffix = nParts[nParts.length - 1];
+            if (nSuffix) {
+                for (const [, candidate] of index) {
+                    const cName = candidate.name;
+                    const cParts = cName.split("__");
+                    const cSuffix = cParts[cParts.length - 1];
+                    if (cSuffix === nSuffix && cName.includes(nParts[0]))
+                        return candidate;
+                }
+            }
+            return { name: n, error: "not found" };
+        });
+        return jsonResponse(res, 200, results);
     }
     catch (err) {
-        log(`[${name}] Connection failed:`, err.message);
-        return null;
+        return jsonResponse(res, 500, { error: err.message });
     }
 }
-/** Refresh tools from a specific upstream */
-async function refreshTools(server) {
+async function handleCall(req, res) {
+    const body = await parseBody(req);
+    const method = body.method;
+    const name = body.name;
+    const args = (body.args || {});
+    if (!name) {
+        return jsonResponse(res, 400, { error: "name is required" });
+    }
+    const validMethods = [
+        "call_tool_read",
+        "call_tool_write",
+        "call_tool_destructive",
+    ];
+    if (method && !validMethods.includes(method)) {
+        return jsonResponse(res, 400, {
+            error: `Invalid method: ${method}. Must be one of: ${validMethods.join(", ")}`,
+        });
+    }
     try {
-        const result = await server.client.listTools();
-        server.tools = (result.tools || []);
-        log(`[${server.name}] Refreshed: ${server.tools.length} tools`);
+        await ensureSession();
+        callCount++;
+        const toolName = method || "call_tool_read";
+        const callArgs = { name, args };
+        if (body.reason)
+            callArgs.intent_reason = body.reason;
+        if (body.sensitivity)
+            callArgs.intent_data_sensitivity = body.sensitivity;
+        const forwardArgs = transformToolCallArgs(toolName, callArgs);
+        const resp = await mcpRequest("tools/call", {
+            name: toolName,
+            arguments: forwardArgs,
+        });
+        if (!resp) {
+            return jsonResponse(res, 502, { error: "No response from upstream" });
+        }
+        if (resp.error) {
+            if (resp.error.message?.includes("session") ||
+                resp.error.message?.includes("Session") ||
+                resp.error.code === -32001) {
+                const ok = await reinitOnExpiry();
+                if (ok) {
+                    const retry = await mcpRequest("tools/call", {
+                        name: toolName,
+                        arguments: forwardArgs,
+                    });
+                    if (retry && !retry.error) {
+                        return jsonResponse(res, 200, unwrapForRest(retry.result));
+                    }
+                }
+            }
+            return jsonResponse(res, 502, {
+                error: "upstream error",
+                detail: resp.error,
+            });
+        }
+        return jsonResponse(res, 200, unwrapForRest(resp.result));
     }
     catch (err) {
-        log(`[${server.name}] Tool refresh failed:`, err.message);
+        return jsonResponse(res, 500, { error: err.message });
     }
 }
-// ---------------------------------------------------------------------------
-// Aggregated tool list + helper tools
-// ---------------------------------------------------------------------------
-/** Build a usage guide for the current daemon state */
-function buildUsageGuide() {
-    const servers = [...upstreams.values()].filter((s) => s.connected);
-    const lines = [
-        "# MCP Daemon — Usage Guide",
-        "",
-        "This is an MCP gateway that aggregates tools from multiple upstream servers.",
-        "All tools are namespaced: `<server>__<tool>` (double underscore separator).",
-        "",
-        "## Connected Servers",
-        "",
-    ];
-    for (const server of servers) {
-        const type = server.config.type;
-        lines.push(`### \`${server.name}\` (${type})`);
-        lines.push("");
-        lines.push(`Tools (${server.tools.length}):`);
-        for (const tool of server.tools) {
-            const desc = tool.description ? ` — ${tool.description.slice(0, 80)}${tool.description.length > 80 ? "..." : ""}` : "";
-            lines.push(`- \`${namespaceTool(server.name, tool.name)}\`${desc}`);
+async function handleExec(req, res) {
+    const body = await parseBody(req);
+    const code = body.code;
+    if (!code) {
+        return jsonResponse(res, 400, { error: "code is required" });
+    }
+    try {
+        await ensureSession();
+        callCount++;
+        const resp = await mcpRequest("tools/call", {
+            name: "code_execution",
+            arguments: { code },
+        });
+        if (!resp) {
+            return jsonResponse(res, 502, { error: "No response from upstream" });
+        }
+        if (resp.error) {
+            return jsonResponse(res, 502, {
+                error: "upstream error",
+                detail: resp.error,
+            });
         }
-        lines.push("");
+        return jsonResponse(res, 200, unwrapForRest(resp.result));
     }
-    lines.push("## How to Call Tools");
-    lines.push("");
-    lines.push("1. Find the tool you need from the list above");
-    lines.push("2. Call it using the full namespaced name (e.g., `github__get_file_contents`)");
-    lines.push("3. Pass arguments as a native JSON object — no special serialization needed");
-    lines.push("");
-    lines.push("### Example");
-    lines.push("");
-    // Generate a real example from the first server's first tool
-    if (servers.length > 0 && servers[0].tools.length > 0) {
-        const example = servers[0].tools[0];
-        const exampleName = namespaceTool(servers[0].name, example.name);
-        const exampleArgs = example.inputSchema?.properties
-            ? Object.fromEntries(Object.entries(example.inputSchema.properties)
-                .slice(0, 3)
-                .map(([k, v]) => [k, v.type === "number" ? 1 : v.type === "boolean" ? true : "..."]))
-            : {};
-        lines.push("```json");
-        lines.push(`{ "name": "${exampleName}", "arguments": ${JSON.stringify(exampleArgs)} }`);
-        lines.push("```");
+    catch (err) {
+        return jsonResponse(res, 500, { error: err.message });
     }
-    lines.push("");
-    return lines.join("\n");
 }
-/** Shim-local tool schemas injected into the aggregated tool list */
-const DAEMON_HELP_TOOL = {
-    name: "daemon_help",
-    description: "Get usage guide for this MCP daemon — lists all connected servers, " +
-        "their tools (with namespaced names), and how to call them. " +
-        "Call this FIRST if you're unsure how to use this gateway.",
-    inputSchema: {
-        type: "object",
-        properties: {
-            server: {
-                type: "string",
-                description: "Optional: filter help to a specific server name",
-            },
-        },
-    },
-};
-function getAggregatedTools() {
-    const allTools = [DAEMON_HELP_TOOL];
-    for (const [, server] of upstreams) {
-        if (!server.connected)
-            continue;
-        for (const tool of server.tools) {
-            allTools.push({
-                ...tool,
-                name: namespaceTool(server.name, tool.name),
-                description: `[${server.name}] ${tool.description || ""}`.trim(),
-            });
-        }
+async function handleReinit(_req, res) {
+    try {
+        resetSessionId();
+        await ensureSession();
+        return jsonResponse(res, 200, {
+            ok: true,
+            sessionId: (getSessionId() || "").slice(0, 12) + "...",
+        });
+    }
+    catch (err) {
+        return jsonResponse(res, 500, {
+            ok: false,
+            error: err.message,
+        });
     }
-    return allTools;
 }
 // ---------------------------------------------------------------------------
-// Downstream MCP server (exposed to cloud agents)
+// Streamable HTTP /mcp endpoint (backward compat)
 // ---------------------------------------------------------------------------
-const downstreamTransports = new Map();
-async function createDownstreamSession() {
+const mcpTransports = new Map();
+async function createMcpSessionTransport() {
     const transport = new StreamableHTTPServerTransport({
         sessionIdGenerator: () => randomUUID(),
         onsessioninitialized: (sessionId) => {
-            log(`Session initialized: ${sessionId.slice(0, 12)}...`);
-            downstreamTransports.set(sessionId, transport);
+            log(`MCP session initialized: ${sessionId.slice(0, 12)}...`);
+            mcpTransports.set(sessionId, transport);
         },
     });
     transport.onclose = () => {
         const sid = transport.sessionId;
-        if (sid && downstreamTransports.has(sid)) {
-            log(`Session closed: ${sid.slice(0, 12)}...`);
-            downstreamTransports.delete(sid);
+        if (sid && mcpTransports.has(sid)) {
+            log(`MCP session closed: ${sid.slice(0, 12)}...`);
+            mcpTransports.delete(sid);
         }
     };
-    // Build server instructions so clients know how to use the daemon
-    const connectedServers = [...upstreams.values()].filter((s) => s.connected);
-    const serverList = connectedServers.map((s) => `${s.name} (${s.tools.length} tools)`).join(", ");
-    const instructions = [
-        "MCP Daemon — Multi-server gateway.",
-        `Connected servers: ${serverList}.`,
-        "All tools are namespaced as <server>__<tool> (double underscore).",
-        "Call daemon_help for a full usage guide with all available tools.",
-    ].join(" ");
-    // Create MCP server for this session
-    const server = new Server({ name: "mcp-daemon", version: "1.0.0" }, {
-        capabilities: { tools: {} },
-        instructions,
-    });
-    // Handle tools/list — aggregate from all upstreams
-    server.setRequestHandler(ListToolsRequestSchema, async () => {
-        // Refresh tools from all connected upstreams
-        await Promise.allSettled([...upstreams.values()]
-            .filter((s) => s.connected)
-            .map((s) => refreshTools(s)));
-        return { tools: getAggregatedTools() };
-    });
-    // Handle tools/call — route to correct upstream
-    server.setRequestHandler(CallToolRequestSchema, async (request) => {
-        const { name, arguments: args } = request.params;
-        // --- Shim-local: daemon_help ---
-        if (name === "daemon_help") {
-            const filterServer = args?.server || "";
-            if (filterServer) {
-                const upstream = upstreams.get(filterServer);
-                if (!upstream || !upstream.connected) {
-                    return {
-                        content: [{ type: "text", text: `Server "${filterServer}" not found. Connected servers: ${[...upstreams.keys()].join(", ")}` }],
-                        isError: true,
-                    };
-                }
-                // Server-specific help
-                const lines = [
-                    `# Server: ${filterServer} (${upstream.config.type})`,
-                    "",
-                    `## Tools (${upstream.tools.length})`,
-                    "",
-                ];
-                for (const tool of upstream.tools) {
-                    lines.push(`### \`${namespaceTool(filterServer, tool.name)}\``);
-                    if (tool.description)
-                        lines.push(tool.description);
-                    if (tool.inputSchema) {
-                        lines.push("");
-                        lines.push("```json");
-                        lines.push(JSON.stringify(tool.inputSchema, null, 2));
-                        lines.push("```");
-                    }
-                    lines.push("");
-                }
-                return {
-                    content: [{ type: "text", text: lines.join("\n") }],
-                };
-            }
-            return {
-                content: [{ type: "text", text: buildUsageGuide() }],
-            };
-        }
-        const parsed = parseNamespacedTool(name);
-        if (!parsed) {
-            return {
-                content: [{ type: "text", text: JSON.stringify({ error: `Unknown tool: ${name}. Tool names are prefixed with server name (e.g., "myserver__toolname"). Call daemon_help for a full list.` }) }],
-                isError: true,
-            };
-        }
-        const server = upstreams.get(parsed.serverName);
-        if (!server || !server.connected) {
-            return {
-                content: [{ type: "text", text: JSON.stringify({ error: `Server "${parsed.serverName}" is not connected` }) }],
-                isError: true,
-            };
-        }
-        try {
-            const result = await server.client.callTool({
-                name: parsed.toolName,
-                arguments: args || {},
-            });
-            // Passthrough the result as-is
-            if (result.content && Array.isArray(result.content)) {
-                return {
-                    content: result.content,
-                    isError: result.isError === true ? true : undefined,
-                };
-            }
-            // Wrap non-standard results
-            const text = typeof result === "string" ? result : JSON.stringify(result);
-            return { content: [{ type: "text", text }] };
-        }
-        catch (err) {
-            const msg = err.message;
-            log(`[${parsed.serverName}] Tool call error (${parsed.toolName}):`, msg);
-            return {
-                content: [{ type: "text", text: `Error calling ${parsed.serverName}/${parsed.toolName}: ${msg}` }],
-                isError: true,
-            };
-        }
-    });
+    const server = await createShimServer({ lazyInit: true });
     await server.connect(transport);
     return transport;
 }
-// ---------------------------------------------------------------------------
-// HTTP Server
-// ---------------------------------------------------------------------------
-function parseBody(req) {
-    return new Promise((resolve) => {
-        const chunks = [];
-        req.on("data", (chunk) => chunks.push(chunk));
-        req.on("end", () => {
-            try {
-                const raw = Buffer.concat(chunks).toString("utf-8");
-                resolve(raw ? JSON.parse(raw) : null);
-            }
-            catch {
-                resolve(null);
-            }
-        });
-        req.on("error", () => resolve(null));
-    });
-}
 async function handleMcpRequest(req, res) {
-    // CORS
     res.setHeader("Access-Control-Allow-Origin", "*");
     res.setHeader("Access-Control-Allow-Methods", "GET, POST, DELETE, OPTIONS");
     res.setHeader("Access-Control-Allow-Headers", "Content-Type, Mcp-Session-Id, Last-Event-ID");
@@ -434,39 +403,33 @@ async function handleMcpRequest(req, res) {
     try {
         if (req.method === "POST") {
             const body = await parseBody(req);
-            if (sessionId && downstreamTransports.has(sessionId)) {
-                const transport = downstreamTransports.get(sessionId);
+            if (sessionId && mcpTransports.has(sessionId)) {
+                const transport = mcpTransports.get(sessionId);
                 await transport.handleRequest(req, res, body);
             }
             else if (!sessionId && isInitializeRequest(body)) {
-                const transport = await createDownstreamSession();
+                const transport = await createMcpSessionTransport();
                 await transport.handleRequest(req, res, body);
             }
             else {
                 res.writeHead(400, { "Content-Type": "application/json" });
                 res.end(JSON.stringify({
                     jsonrpc: "2.0",
-                    error: { code: -32000, message: "Bad Request: No valid session ID provided" },
+                    error: {
+                        code: -32000,
+                        message: "Bad Request: No valid session ID provided",
+                    },
                     id: null,
                 }));
             }
         }
-        else if (req.method === "GET") {
-            if (!sessionId || !downstreamTransports.has(sessionId)) {
-                res.writeHead(400, { "Content-Type": "text/plain" });
-                res.end("Invalid or missing session ID");
-                return;
-            }
-            const transport = downstreamTransports.get(sessionId);
-            await transport.handleRequest(req, res);
-        }
-        else if (req.method === "DELETE") {
-            if (!sessionId || !downstreamTransports.has(sessionId)) {
+        else if (req.method === "GET" || req.method === "DELETE") {
+            if (!sessionId || !mcpTransports.has(sessionId)) {
                 res.writeHead(400, { "Content-Type": "text/plain" });
                 res.end("Invalid or missing session ID");
                 return;
             }
-            const transport = downstreamTransports.get(sessionId);
+            const transport = mcpTransports.get(sessionId);
             await transport.handleRequest(req, res);
         }
         else {
@@ -475,7 +438,7 @@ async function handleMcpRequest(req, res) {
         }
     }
     catch (error) {
-        log("HTTP handler error:", error.message);
+        log("MCP handler error:", error.message);
         if (!res.headersSent) {
             res.writeHead(500, { "Content-Type": "application/json" });
             res.end(JSON.stringify({
@@ -487,111 +450,85 @@ async function handleMcpRequest(req, res) {
     }
 }
 // ---------------------------------------------------------------------------
-// Main
+// HTTP Server + routing
 // ---------------------------------------------------------------------------
 async function main() {
-    log("Starting MCP Daemon...");
-    const configs = loadConfig();
-    const serverNames = Object.keys(configs);
-    if (serverNames.length === 0) {
-        log("Fatal: No servers defined in configuration.");
-        process.exit(1);
-    }
-    log(`Configured servers: ${serverNames.join(", ")}`);
-    // Connect to all upstream servers in parallel
-    const results = await Promise.allSettled(serverNames.map(async (name) => {
-        const server = await connectServer(name, configs[name]);
-        if (server) {
-            upstreams.set(name, server);
-        }
-        return server;
-    }));
-    const connected = [...upstreams.values()].filter((s) => s.connected);
-    const totalTools = connected.reduce((sum, s) => sum + s.tools.length, 0);
-    if (connected.length === 0) {
-        log("Fatal: No upstream servers connected successfully.");
-        process.exit(1);
+    log("Starting daemon (REST + MCP gateway)...");
+    log(`Upstream: ${maskUrl(UPSTREAM_URL)}`);
+    try {
+        await ensureSession();
+        log("Upstream session established");
     }
-    log(`Connected: ${connected.length}/${serverNames.length} servers, ${totalTools} total tools`);
-    // Print tool summary
-    for (const server of connected) {
-        log(`  [${server.name}] ${server.tools.length} tools: ${server.tools.slice(0, 5).map((t) => t.name).join(", ")}${server.tools.length > 5 ? "..." : ""}`);
+    catch (err) {
+        log("Warning: initial upstream connection failed:", err.message);
+        log("Will retry on first request");
     }
-    // Start HTTP server
     const httpServer = http.createServer((req, res) => {
         const url = new URL(req.url || "/", `http://${req.headers.host || "localhost"}`);
-        if (url.pathname === "/mcp" || url.pathname === "/mcp/") {
-            // Apikey gate
-            if (APIKEY && url.searchParams.get("apikey") !== APIKEY) {
-                res.writeHead(401, { "Content-Type": "application/json" });
-                res.end(JSON.stringify({
-                    jsonrpc: "2.0",
-                    error: { code: -32001, message: "Unauthorized: invalid or missing apikey" },
-                    id: null,
-                }));
-                return;
-            }
-            handleMcpRequest(req, res).catch((err) => {
-                log("Unhandled error:", err.message);
-                if (!res.headersSent) {
-                    res.writeHead(500);
-                    res.end("Internal Server Error");
-                }
-            });
-        }
-        else if (url.pathname === "/health" || url.pathname === "/healthz") {
-            const serverStatus = {};
-            for (const [name, server] of upstreams) {
-                serverStatus[name] = {
-                    connected: server.connected,
-                    tools: server.tools.length,
-                    type: server.config.type,
-                };
-            }
-            res.writeHead(200, { "Content-Type": "application/json" });
-            res.end(JSON.stringify({
-                status: "ok",
-                sessions: downstreamTransports.size,
-                uptime: process.uptime(),
-                servers: serverStatus,
-                totalTools,
-            }));
+        const pathname = url.pathname;
+        if (APIKEY && url.searchParams.get("apikey") !== APIKEY) {
+            res.writeHead(401, { "Content-Type": "application/json" });
+            res.end(JSON.stringify({ error: "Unauthorized: invalid or missing apikey" }));
+            return;
         }
-        else {
-            res.writeHead(404, { "Content-Type": "text/plain" });
-            res.end("Not Found — MCP endpoint is at /mcp");
+        if (req.method === "OPTIONS") {
+            res.setHeader("Access-Control-Allow-Origin", "*");
+            res.setHeader("Access-Control-Allow-Methods", "GET, POST, DELETE, OPTIONS");
+            res.setHeader("Access-Control-Allow-Headers", "Content-Type, Mcp-Session-Id, Last-Event-ID");
+            res.writeHead(204);
+            res.end();
+            return;
         }
+        const handler = async () => {
+            if (pathname === "/health" || pathname === "/healthz") {
+                return handleHealth(req, res);
+            }
+            if (pathname === "/retrieve_tools" && req.method === "POST") {
+                return handleRetrieveTools(req, res);
+            }
+            if (pathname === "/describe_tools" && req.method === "POST") {
+                return handleDescribeTools(req, res);
+            }
+            if (pathname === "/call" && req.method === "POST") {
+                return handleCall(req, res);
+            }
+            if (pathname === "/exec" && req.method === "POST") {
+                return handleExec(req, res);
+            }
+            if (pathname === "/reinit" && req.method === "POST") {
+                return handleReinit(req, res);
+            }
+            if (pathname === "/mcp" || pathname === "/mcp/") {
+                return handleMcpRequest(req, res);
+            }
+            res.writeHead(404, { "Content-Type": "application/json" });
+            res.end(JSON.stringify({ error: "Not Found" }));
+        };
+        handler().catch((err) => {
+            log("Unhandled error:", err.message);
+            if (!res.headersSent) {
+                res.writeHead(500, { "Content-Type": "application/json" });
+                res.end(JSON.stringify({ error: "Internal Server Error" }));
+            }
+        });
     });
     httpServer.listen(PORT, HOST, () => {
-        log(`Daemon listening on http://${HOST}:${PORT}/mcp`);
-        log(`Health check: http://${HOST}:${PORT}/health`);
+        log(`Daemon listening on http://${HOST}:${PORT}`);
+        log("REST endpoints: /health, /retrieve_tools, /describe_tools, /call, /exec, /reinit");
+        log("MCP endpoint: /mcp");
         log(`Auth: ${APIKEY ? "apikey required (?apikey=...)" : "OPEN (no MCP_APIKEY set)"}`);
-        log("Waiting for MCP client connections...");
     });
-    // Graceful shutdown
     const shutdown = async () => {
         log("Shutting down daemon...");
-        // Close downstream sessions
-        for (const [sid, transport] of downstreamTransports) {
+        for (const [sid, transport] of mcpTransports) {
             try {
                 await transport.close();
             }
             catch (err) {
-                log(`Error closing session ${sid.slice(0, 12)}:`, err.message);
-            }
-        }
-        downstreamTransports.clear();
-        // Disconnect upstream servers
-        for (const [name, server] of upstreams) {
-            try {
-                log(`Disconnecting [${name}]...`);
-                await server.client.close();
-            }
-            catch (err) {
-                log(`Error disconnecting [${name}]:`, err.message);
+                log(`Error closing MCP session ${sid.slice(0, 12)}:`, err.message);
             }
         }
-        upstreams.clear();
+        mcpTransports.clear();
         httpServer.close(() => {
             log("Daemon stopped");
             process.exit(0);