@silver886/mcp-proxy 0.2.5 → 0.2.6

package/dist/host/agent.d.ts

@@ -19,4 +19,6 @@ export declare class HostAgent {
     private authorized;
     private handleMcpPost;
     private handleSse;
+    private handleAdminRestart;
+    private restartServer;
 }

package/dist/host/agent.js

@@ -186,6 +186,15 @@ class HostAgent {
             }));
             return;
         }
+        if (pathname === "/admin/restart") {
+            if (req.method !== "POST") {
+                res.writeHead(405);
+                res.end();
+                return;
+            }
+            await this.handleAdminRestart(req, res);
+            return;
+        }
         const match = pathname.match(/^\/servers\/([^/]+)$/);
         if (!match) {
             res.writeHead(404, { "Content-Type": "application/json" });
@@ -357,5 +366,62 @@ class HostAgent {
         }, constants_js_1.SSE_DRAIN_INTERVAL_MS);
         req.on("close", () => clearInterval(interval));
     }
+    // POST /admin/restart  body: { "server": "<name>" }
+    // Kills every live session for that server. The next forward from the
+    // proxy will see a 404 (because the session id is gone from the map),
+    // re-`initialize` via the proxy's existing stale-session recovery, and
+    // spawn a fresh child. The host doesn't need to know about hosts/aliases
+    // — it trusts the bearer for scoping.
+    async handleAdminRestart(req, res) {
+        const body = await (0, protocol_js_1.readBody)(req);
+        let parsed;
+        try {
+            parsed = JSON.parse(body);
+        }
+        catch {
+            res.writeHead(400, { "Content-Type": "application/json" });
+            res.end(JSON.stringify({ error: "server is required" }));
+            return;
+        }
+        const serverName = parsed.server;
+        if (typeof serverName !== "string" || serverName.length === 0) {
+            res.writeHead(400, { "Content-Type": "application/json" });
+            res.end(JSON.stringify({ error: "server is required" }));
+            return;
+        }
+        if (!this.config.servers[serverName]) {
+            // Mirror the /servers/:name miss shape (agent.ts:218-221) so the proxy
+            // can forward `available` straight into the LLM-facing error.
+            res.writeHead(404, { "Content-Type": "application/json" });
+            res.end(JSON.stringify({
+                error: `Unknown server: ${serverName}`,
+                available: Object.keys(this.config.servers),
+            }));
+            return;
+        }
+        const killed = this.restartServer(serverName);
+        res.writeHead(200, { "Content-Type": "application/json" });
+        res.end(JSON.stringify({ ok: true, killed }));
+    }
+    // Destroy + drop every live session belonging to `name`. killed=0 is
+    // success — the post-condition (no live session for this server) is met
+    // either way. McpSession.destroy synchronously fails pending requests
+    // with PROCESS_EXITED (so in-flight forwards resolve immediately rather
+    // than waiting on the per-request timeout) and tree-kills the whole
+    // process group (so `shell: true` / `npx` configs don't leave the real
+    // MCP server alive as a grandchild).
+    restartServer(name) {
+        let killed = 0;
+        for (const [id, session] of this.sessions) {
+            if (session.serverName !== name)
+                continue;
+            session.destroy();
+            this.sessions.delete(id);
+            killed++;
+        }
+        if (killed > 0)
+            console.log(`[${name}] Restarted: ${killed} session(s) destroyed`);
+        return killed;
+    }
 }
 exports.HostAgent = HostAgent;

package/dist/host/session.js

@@ -1,7 +1,11 @@
 "use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.McpSession = void 0;
 const node_child_process_1 = require("node:child_process");
+const tree_kill_1 = __importDefault(require("tree-kill"));
 const protocol_js_1 = require("../shared/protocol.js");
 const constants_js_1 = require("./constants.js");
 // One McpSession owns a single MCP server child process and matches its
@@ -193,12 +197,37 @@ class McpSession {
     get isAlive() {
         return !this.destroyed;
     }
+    // Idempotent. Three steps, in order:
+    //
+    //   1. Mark destroyed BEFORE failing pending so any synchronous
+    //      sendRequest racing on another tick short-circuits to
+    //      PROCESS_NOT_RUNNING instead of registering into a map we're
+    //      about to drain.
+    //   2. failPending synchronously: don't wait for the child's 'exit'
+    //      handler. A child that ignores SIGTERM (or a shell wrapper that
+    //      swallows it) would otherwise leave callers waiting the full
+    //      per-request timeout. The 'exit' handler's later failPending
+    //      becomes a no-op against the now-empty map.
+    //   3. tree-kill the WHOLE process group, not just the direct child.
+    //      Documented configs use `shell: true` / `npx`, where the real MCP
+    //      server is a grandchild of /bin/sh; a bare process.kill() leaves
+    //      it alive after the shell exits, which would silently break
+    //      restart_server's contract ("session destroyed" but the wedged
+    //      child is still answering on stdin somewhere).
     destroy() {
         if (this.destroyed)
             return;
         this.destroyed = true;
-        if (!this.process.killed)
-            this.process.kill();
+        this.failPending(protocol_js_1.ErrorCode.PROCESS_EXITED, "session destroyed");
+        if (!this.process.killed && this.process.pid !== undefined) {
+            // Default signal is SIGTERM; tree-kill walks ps/taskkill on
+            // POSIX/Windows and signals every descendant. Errors here mean the
+            // tree is already gone (race with natural exit) — best-effort.
+            (0, tree_kill_1.default)(this.process.pid, (err) => {
+                if (err)
+                    console.error(`[${this.name}] tree-kill failed: ${err.message}`);
+            });
+        }
     }
 }
 exports.McpSession = McpSession;

package/dist/proxy/core/constants.d.ts

@@ -13,3 +13,5 @@ export declare const SSE_BACKOFF_MAX_MS = 10000;
 export declare const SSE_CONNECT_TIMEOUT_MS = 15000;
 export declare const CONFIGURE_TOOL: Tool;
 export declare const CONFIGURE_PROMPT: Prompt;
+export declare const RESTART_SERVER_TOOL: Tool;
+export declare const RESTART_SERVER_PROMPT: Prompt;

package/dist/proxy/core/constants.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.CONFIGURE_PROMPT = exports.CONFIGURE_TOOL = exports.SSE_CONNECT_TIMEOUT_MS = exports.SSE_BACKOFF_MAX_MS = exports.SSE_BACKOFF_INITIAL_MS = exports.PAIRING_REQUEST_TIMEOUT_MS = exports.PAIRING_HEADERS_TIMEOUT_MS = exports.SESSION_DELETE_TIMEOUT_MS = exports.TOOL_FORWARD_TIMEOUT_MS = exports.DISCOVERY_FETCH_TIMEOUT_MS = exports.UPSTREAM_REQUEST_TIMEOUT_MS = exports.PAIRING_WINDOW_MS = exports.TUNNEL_STARTUP_TIMEOUT_MS = exports.TOOL_SEPARATOR = void 0;
+exports.RESTART_SERVER_PROMPT = exports.RESTART_SERVER_TOOL = exports.CONFIGURE_PROMPT = exports.CONFIGURE_TOOL = exports.SSE_CONNECT_TIMEOUT_MS = exports.SSE_BACKOFF_MAX_MS = exports.SSE_BACKOFF_INITIAL_MS = exports.PAIRING_REQUEST_TIMEOUT_MS = exports.PAIRING_HEADERS_TIMEOUT_MS = exports.SESSION_DELETE_TIMEOUT_MS = exports.TOOL_FORWARD_TIMEOUT_MS = exports.DISCOVERY_FETCH_TIMEOUT_MS = exports.UPSTREAM_REQUEST_TIMEOUT_MS = exports.PAIRING_WINDOW_MS = exports.TUNNEL_STARTUP_TIMEOUT_MS = exports.TOOL_SEPARATOR = void 0;
 const protocol_js_1 = require("../../shared/protocol.js");
 exports.TOOL_SEPARATOR = protocol_js_1.TOOL_NAME_SEPARATOR;
 // Pairing-tunnel + bridging budgets.
@@ -44,3 +44,41 @@ exports.CONFIGURE_PROMPT = {
     name: "configure",
     description: "Set up or reconfigure the MCP proxy connection.",
 };
+// Local tool: kill the host's child process for a wedged MCP server so the
+// next forward re-spawns it. The description teaches the LLM how to format
+// the `tool` argument, since the form it sees in its catalog (wrapped by
+// its MCP client as `mcp__<alias>__...`) is NOT the form the proxy parses.
+exports.RESTART_SERVER_TOOL = {
+    name: "restart_server",
+    description: "Restart a wedged MCP server (kills the host's child process; next call respawns it). "
+        + "Pass `tool` as the proxy-internal name `<host>__<server>__<tool>`. "
+        + "If your tool catalog shows it as `mcp__<alias>__<host>__<server>__<tool>`, strip the `mcp__<alias>__` prefix first. "
+        + "Or pass `host` and `server` directly (visible in every tool's description as `[<host>/<server>]`).",
+    inputSchema: {
+        type: "object",
+        properties: {
+            tool: {
+                type: "string",
+                description: "Proxy-internal tool name <host>__<server>__<tool>. Strip any mcp__<alias>__ wrapper your client adds.",
+            },
+            host: { type: "string", description: "Host id (alternative to tool)." },
+            server: { type: "string", description: "Server name (alternative to tool)." },
+        },
+    },
+};
+// Local prompt counterpart. Same handler, same parser — the prompt is just
+// another entry point so an operator can drive a restart from the picker
+// without round-tripping through the LLM's planner.
+exports.RESTART_SERVER_PROMPT = {
+    name: "restart_server",
+    description: "Restart a wedged MCP server (kills the host's child; next call respawns).",
+    arguments: [
+        {
+            name: "tool",
+            description: "Proxy-internal tool name <host>__<server>__<tool>. Strip any mcp__<alias>__ wrapper your client adds.",
+            required: false,
+        },
+        { name: "host", description: "Host id (alternative to tool).", required: false },
+        { name: "server", description: "Server name (alternative to tool).", required: false },
+    ],
+};

package/dist/proxy/pairing/config.js

@@ -67,11 +67,12 @@ function validatePairingConfig(cfg) {
     // server-level allow list never triggered. Catching it here keeps the
     // invariant on the way IN to ProxyServer state.
     //
-    // Server names may themselves contain `__`, so we don't `split` — we
-    // take the prefix before the FIRST `__` as the hostId and require the
-    // remainder (the serverName) to be non-empty so a malformed entry like
-    // `host__` doesn't sneak through as a valid-looking allowlist line that
-    // can never match any real server.
+    // Mirrors the indexOf form used by the selectedTools parser below for
+    // consistency. validateServerName forbids `__` in both the hostId and
+    // the serverName, so a single split on the FIRST `__` is sound; the
+    // remainder must be non-empty so a malformed entry like `host__`
+    // doesn't sneak through as a valid-looking allowlist line that can
+    // never match any real server.
     const validHostIds = new Set(validatedHosts.map((h) => h.id));
     if (cfg.selectedServers) {
         for (const entry of cfg.selectedServers) {
@@ -95,12 +96,13 @@ function validatePairingConfig(cfg) {
     // actually carry a tool name: an entry whose server prefix isn't in
     // selectedServers (when defined) — or whose hostId isn't a known host
     // (when selectedServers is omitted) — is unreachable noise that hides
-    // bugs in the UI or stale configs. Tool/server names may themselves
-    // contain `__`, so we prefix-match the allowed scope rather than
-    // splitting on the separator. Shape is enforced separately by requiring
-    // at least two `__` occurrences — the prefix-match alone degraded to a
-    // hostId-only check when `selectedServers` was omitted, letting entries
-    // like `host__bogus` survive without a tool segment.
+    // bugs in the UI or stale configs. validateServerName forbids `__` in
+    // host id and server name, but tool names CAN contain `__`, so we
+    // prefix-match the allowed scope rather than splitting on the separator.
+    // Shape is enforced separately by requiring at least two `__` occurrences
+    // — the prefix-match alone degraded to a hostId-only check when
+    // `selectedServers` was omitted, letting entries like `host__bogus`
+    // survive without a tool segment.
     if (cfg.selectedTools) {
         const allowedServerPrefixes = cfg.selectedServers
             ? cfg.selectedServers.map((s) => `${s}${constants_js_1.TOOL_SEPARATOR}`)

package/dist/proxy/pairing/controller.js

@@ -253,8 +253,9 @@ class PairingController {
         // to "every advertised host must land at least one server".
         const missing = [];
         if (cfg.selectedServers) {
-            // Server names may contain `__`, so prefix-match on the FIRST `__`
-            // — same parsing rule used in validatePairingConfig.
+            // validateServerName forbids `__` in host id and server name, so
+            // a single split on the FIRST `__` is sound — same parsing rule
+            // used in validatePairingConfig.
             for (const key of cfg.selectedServers) {
                 const sep = key.indexOf("__");
                 if (sep <= 0)

package/dist/proxy/runtime/handlers.d.ts

@@ -2,6 +2,7 @@ import type { ProxyState } from "../core/state.js";
 import type { DiscoveryRunner } from "../discovery/runner.js";
 import type { PairingController } from "../pairing/controller.js";
 import type { Forwarder } from "./forwarder.js";
+import { type RestartHandler } from "./restart.js";
 import type { UpstreamBridge } from "./upstream-bridge.js";
 export declare class RequestHandlers {
     private readonly state;
@@ -9,9 +10,10 @@ export declare class RequestHandlers {
     private readonly forwarder;
     private readonly pairing;
     private readonly bridge;
+    private readonly restart;
     private readonly sendResult;
     private readonly sendError;
-    constructor(state: ProxyState, runner: DiscoveryRunner, forwarder: Forwarder, pairing: PairingController, bridge: UpstreamBridge, sendResult: (id: string | number | null, result: unknown) => void, sendError: (code: number, detail: string | undefined, id: string | number | null) => void);
+    constructor(state: ProxyState, runner: DiscoveryRunner, forwarder: Forwarder, pairing: PairingController, bridge: UpstreamBridge, restart: RestartHandler, sendResult: (id: string | number | null, result: unknown) => void, sendError: (code: number, detail: string | undefined, id: string | number | null) => void);
     handleInitialize(id: string | number, params: {
         capabilities?: Record<string, unknown>;
         clientInfo?: {

package/dist/proxy/runtime/handlers.js

@@ -5,6 +5,7 @@ const protocol_js_1 = require("../../shared/protocol.js");
 const constants_js_1 = require("../core/constants.js");
 const filtering_js_1 = require("../routing/filtering.js");
 const uri_js_1 = require("../routing/uri.js");
+const restart_js_1 = require("./restart.js");
 // One method per JSON-RPC verb the agent can send. Each handler is
 // responsible for: parameter validation, looking up the route from the
 // (already discovered) state, and either answering locally or delegating
@@ -17,14 +18,16 @@ class RequestHandlers {
     forwarder;
     pairing;
     bridge;
+    restart;
     sendResult;
     sendError;
-    constructor(state, runner, forwarder, pairing, bridge, sendResult, sendError) {
+    constructor(state, runner, forwarder, pairing, bridge, restart, sendResult, sendError) {
         this.state = state;
         this.runner = runner;
         this.forwarder = forwarder;
         this.pairing = pairing;
         this.bridge = bridge;
+        this.restart = restart;
         this.sendResult = sendResult;
         this.sendError = sendError;
     }
@@ -54,24 +57,33 @@ class RequestHandlers {
     }
     async handleToolsList(id) {
         if (!this.state.config) {
-            this.sendResult(id, { tools: [constants_js_1.CONFIGURE_TOOL] });
+            this.sendResult(id, { tools: [constants_js_1.CONFIGURE_TOOL, constants_js_1.RESTART_SERVER_TOOL] });
             return;
         }
         await this.runner.retryDiscoveryIfNeeded();
         this.sendResult(id, {
-            tools: [constants_js_1.CONFIGURE_TOOL, ...(0, filtering_js_1.getFilteredTools)(this.state.config, this.state.hosts, this.state.toolRoute)],
+            tools: [
+                constants_js_1.CONFIGURE_TOOL,
+                constants_js_1.RESTART_SERVER_TOOL,
+                ...(0, filtering_js_1.getFilteredTools)(this.state.config, this.state.hosts, this.state.toolRoute),
+            ],
         });
     }
     async handlePromptsList(id) {
         if (!this.state.config) {
-            this.sendResult(id, { prompts: [constants_js_1.CONFIGURE_PROMPT] });
+            this.sendResult(id, { prompts: [constants_js_1.CONFIGURE_PROMPT, constants_js_1.RESTART_SERVER_PROMPT] });
             return;
         }
         await this.runner.retryDiscoveryIfNeeded();
-        // Inject CONFIGURE_PROMPT first so re-pairing is always one prompt away
-        // regardless of upstream state.
+        // Inject CONFIGURE_PROMPT and RESTART_SERVER_PROMPT first so re-pair
+        // and wedge-recovery are always one prompt away regardless of upstream
+        // state.
         this.sendResult(id, {
-            prompts: [constants_js_1.CONFIGURE_PROMPT, ...(0, filtering_js_1.getAggregatedPrompts)(this.state.config, this.state.hosts, this.state.promptRoute)],
+            prompts: [
+                constants_js_1.CONFIGURE_PROMPT,
+                constants_js_1.RESTART_SERVER_PROMPT,
+                ...(0, filtering_js_1.getAggregatedPrompts)(this.state.config, this.state.hosts, this.state.promptRoute),
+            ],
         });
     }
     async handlePromptDispatch(id, params) {
@@ -97,6 +109,27 @@ class RequestHandlers {
             });
             return;
         }
+        if (promptName === "restart_server") {
+            let target;
+            try {
+                target = await this.restart.run(params?.arguments);
+            }
+            catch (err) {
+                if (err instanceof restart_js_1.RestartError) {
+                    this.sendError(err.code, err.message, id);
+                    return;
+                }
+                this.sendError(protocol_js_1.ErrorCode.INTERNAL, err.message, id);
+                return;
+            }
+            this.sendResult(id, {
+                messages: [
+                    { role: "user", content: { type: "text", text: `Restart ${target.server} on ${target.host}.` } },
+                    { role: "assistant", content: { type: "text", text: `Restarted ${target.server} on ${target.host}. Next call will respawn.` } },
+                ],
+            });
+            return;
+        }
         if (!promptName) {
             this.sendError(protocol_js_1.ErrorCode.INVALID_PARAMS, "name is required", id);
             return;
@@ -258,6 +291,24 @@ class RequestHandlers {
             this.sendResult(id, { content: [{ type: "text", text }] });
             return;
         }
+        if (toolName === "restart_server") {
+            let target;
+            try {
+                target = await this.restart.run(params.arguments);
+            }
+            catch (err) {
+                if (err instanceof restart_js_1.RestartError) {
+                    this.sendError(err.code, err.message, id);
+                    return;
+                }
+                this.sendError(protocol_js_1.ErrorCode.INTERNAL, err.message, id);
+                return;
+            }
+            this.sendResult(id, {
+                content: [{ type: "text", text: `Restarted ${target.server} on ${target.host}. Next call will respawn.` }],
+            });
+            return;
+        }
         if (!this.state.config) {
             this.sendError(protocol_js_1.ErrorCode.PROXY_NOT_CONFIGURED, "Call the `configure` tool first.", id);
             return;

package/dist/proxy/runtime/restart.d.ts

@@ -0,0 +1,17 @@
+import type { ProxyState } from "../core/state.js";
+export declare class RestartError extends Error {
+    readonly code: number;
+    constructor(code: number, message: string);
+}
+export declare class RestartHandler {
+    private readonly state;
+    constructor(state: ProxyState);
+    parse(args: Record<string, unknown> | undefined): {
+        host: string;
+        server: string;
+    };
+    run(args: Record<string, unknown> | undefined): Promise<{
+        host: string;
+        server: string;
+    }>;
+}

package/dist/proxy/runtime/restart.js

@@ -0,0 +1,119 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RestartHandler = exports.RestartError = void 0;
+const protocol_js_1 = require("../../shared/protocol.js");
+const constants_js_1 = require("../core/constants.js");
+const fetch_timeout_js_1 = require("../core/fetch-timeout.js");
+// Typed error so the handlers layer can map a thrown failure straight to a
+// JSON-RPC error code without a second taxonomy. Anything thrown out of
+// RestartHandler.run carries one of ErrorCode.INVALID_PARAMS,
+// HOST_UNREACHABLE, or INTERNAL.
+class RestartError extends Error {
+    code;
+    constructor(code, message) {
+        super(message);
+        this.code = code;
+        this.name = "RestartError";
+    }
+}
+exports.RestartError = RestartError;
+// Owns the restart_server pipeline shared between the tool and prompt
+// dispatch paths in RequestHandlers. Pure orchestrator — owns no state of
+// its own; consults ProxyState for host resolution and POSTs the host's
+// admin endpoint.
+class RestartHandler {
+    state;
+    constructor(state) {
+        this.state = state;
+    }
+    // Parse the (tool? | host+server) input shape. Returns the resolved
+    // (host, server) pair or throws RestartError(INVALID_PARAMS) with a
+    // message the LLM can self-correct on.
+    parse(args) {
+        const tool = typeof args?.tool === "string" ? args.tool : undefined;
+        const host = typeof args?.host === "string" ? args.host : undefined;
+        const server = typeof args?.server === "string" ? args.server : undefined;
+        const hasTool = tool !== undefined && tool.length > 0;
+        const hasPair = host !== undefined && host.length > 0 && server !== undefined && server.length > 0;
+        const hasHalfPair = (host !== undefined && host.length > 0) !== (server !== undefined && server.length > 0);
+        if (hasTool && (host !== undefined || server !== undefined)) {
+            throw new RestartError(protocol_js_1.ErrorCode.INVALID_PARAMS, "exactly one of `tool` or `(host, server)` is required");
+        }
+        if (!hasTool && !hasPair) {
+            if (hasHalfPair) {
+                throw new RestartError(protocol_js_1.ErrorCode.INVALID_PARAMS, "both `host` and `server` are required when `tool` is not provided");
+            }
+            throw new RestartError(protocol_js_1.ErrorCode.INVALID_PARAMS, "exactly one of `tool` or `(host, server)` is required");
+        }
+        if (hasPair)
+            return { host: host, server: server };
+        // Parse `<host>__<server>[__<tool…>]`. host id and server name both
+        // pass validateServerName at ingress (forbids `__`), so two indexOf
+        // calls is sound — tool name segment may itself contain `__` and is
+        // discarded.
+        const sep = constants_js_1.TOOL_SEPARATOR;
+        const firstSep = tool.indexOf(sep);
+        if (firstSep < 0) {
+            throw new RestartError(protocol_js_1.ErrorCode.INVALID_PARAMS, `tool must be <host>__<server> or <host>__<server>__<tool>; if your client shows it as mcp__<alias>__..., strip that prefix first`);
+        }
+        const parsedHost = tool.slice(0, firstSep);
+        if (parsedHost.length === 0) {
+            throw new RestartError(protocol_js_1.ErrorCode.INVALID_PARAMS, "tool has empty host segment");
+        }
+        const afterHost = tool.slice(firstSep + sep.length);
+        const secondSep = afterHost.indexOf(sep);
+        const parsedServer = secondSep < 0 ? afterHost : afterHost.slice(0, secondSep);
+        if (parsedServer.length === 0) {
+            throw new RestartError(protocol_js_1.ErrorCode.INVALID_PARAMS, "tool has empty server segment");
+        }
+        return { host: parsedHost, server: parsedServer };
+    }
+    // Resolve, dispatch, return the resolved pair on success. The proxy does
+    // NOT mutate `server.sessionId`, `subscriptions`, or `sseControllers`
+    // here — the existing 404 recovery in forwarder.ts handles re-init
+    // naturally on the next forward, so all three triggers (idle GC, host
+    // restart, restart_server) flow through one path.
+    async run(args) {
+        const { host: hostId, server: serverName } = this.parse(args);
+        const host = this.state.hosts.get(hostId);
+        if (!host) {
+            const available = Array.from(this.state.hosts.keys()).join(", ") || "(none paired)";
+            throw new RestartError(protocol_js_1.ErrorCode.INVALID_PARAMS, `Unknown host: ${hostId} (available: ${available})`);
+        }
+        const url = `${host.config.tunnelUrl}/admin/restart`;
+        let resp;
+        try {
+            resp = await fetch(url, {
+                method: "POST",
+                headers: this.state.hostHeaders(host.config),
+                signal: (0, fetch_timeout_js_1.timeoutSignal)(constants_js_1.DISCOVERY_FETCH_TIMEOUT_MS),
+                body: JSON.stringify({ server: serverName }),
+            });
+        }
+        catch (err) {
+            throw new RestartError(protocol_js_1.ErrorCode.HOST_UNREACHABLE, `Host unreachable: ${err.message}`);
+        }
+        const text = await resp.text();
+        if (resp.status === 404) {
+            // Host returned the same shape as /servers/:name miss; surface its
+            // `available` list so the LLM can self-correct without another
+            // discovery round-trip.
+            let available = "(unknown)";
+            try {
+                const body = JSON.parse(text);
+                if (Array.isArray(body.available))
+                    available = body.available.join(", ");
+            }
+            catch { /* fall through with placeholder */ }
+            throw new RestartError(protocol_js_1.ErrorCode.INVALID_PARAMS, `Unknown server: ${serverName} on ${hostId} (available: ${available})`);
+        }
+        if (resp.status === 401) {
+            throw new RestartError(protocol_js_1.ErrorCode.HOST_UNREACHABLE, `Host rejected admin bearer (401) for ${hostId}`);
+        }
+        if (!resp.ok) {
+            throw new RestartError(protocol_js_1.ErrorCode.HOST_UNREACHABLE, `Host returned ${resp.status} for ${hostId}: ${text.slice(0, 200)}`);
+        }
+        return { host: hostId, server: serverName };
+    }
+}
+exports.RestartHandler = RestartHandler;

package/dist/proxy/server.js

@@ -8,6 +8,7 @@ const runner_js_1 = require("./discovery/runner.js");
 const controller_js_1 = require("./pairing/controller.js");
 const forwarder_js_1 = require("./runtime/forwarder.js");
 const handlers_js_1 = require("./runtime/handlers.js");
+const restart_js_1 = require("./runtime/restart.js");
 const sse_js_1 = require("./runtime/sse.js");
 const upstream_bridge_js_1 = require("./runtime/upstream-bridge.js");
 // Composition root + JSON-RPC line router. Holds no business logic of
@@ -68,7 +69,8 @@ class ProxyServer {
         this.runner = new runner_js_1.DiscoveryRunner(this.state, this.sse, log);
         this.forwarder = new forwarder_js_1.Forwarder(this.state, this.runner, log, sendError, writeOut);
         this.pairing = new controller_js_1.PairingController(this.state, this.runner, this.bridge, log, sendNotification);
-        this.handlers = new handlers_js_1.RequestHandlers(this.state, this.runner, this.forwarder, this.pairing, this.bridge, sendResult, sendError);
+        const restart = new restart_js_1.RestartHandler(this.state);
+        this.handlers = new handlers_js_1.RequestHandlers(this.state, this.runner, this.forwarder, this.pairing, this.bridge, restart, sendResult, sendError);
     }
     start() {
         const stdinBuffer = new protocol_js_1.LineBuffer();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@silver886/mcp-proxy",
-  "version": "0.2.5",
+  "version": "0.2.6",
   "description": "MCP proxy bridge: forward MCP requests across network boundaries via Cloudflare tunnel",
   "repository": {
     "type": "git",
@@ -39,7 +39,8 @@
   },
   "dependencies": {
     "cloudflared": "^0.7.1",
-    "eventsource-parser": "^3.0.8"
+    "eventsource-parser": "^3.0.8",
+    "tree-kill": "^1.2.2"
   },
   "devDependencies": {
     "@types/node": "^20.0.0",
@@ -56,6 +57,11 @@
       "version": "3.0.8",
       "tarball": "https://registry.npmjs.org/eventsource-parser/-/eventsource-parser-3.0.8.tgz",
       "integrity": "sha512-70QWGkr4snxr0OXLRWsFLeRBIRPuQOvt4s8QYjmUlmlkyTZkRqS7EDVRZtzU3TiyDbXSzaOeF0XUKy8PchzukQ=="
+    },
+    "tree-kill": {
+      "version": "1.2.2",
+      "tarball": "https://registry.npmjs.org/tree-kill/-/tree-kill-1.2.2.tgz",
+      "integrity": "sha512-L0Orpi8qGpRG//Nd+H90vFB+3iHnue1zSSGmNOOCh1GLJ7rUKVwV2HvijphGQS2UmhUZewS9VgvxYIdgr+fG1A=="
     }
   },
   "scripts": {