@silver886/mcp-proxy 0.2.4 → 0.2.6

package/dist/proxy/runtime/forwarder.js

@@ -39,6 +39,13 @@ class Forwarder {
             return h;
         };
         const body = JSON.stringify({ jsonrpc: "2.0", id, method, params: upstreamParams });
+        // Snapshot the active pairing so a re-pair landing while this fetch is
+        // in flight can be detected before we write a stale response back to the
+        // agent. closeAllSessions clears state.inflight, but our local closure
+        // still holds the id/route, so without this guard the OLD pairing's
+        // response (or its upstream-level error) would be emitted on stdout
+        // against a pairing that no longer exists.
+        const startGeneration = this.state.configGeneration;
         this.state.inflight.set(id, route);
         const progressToken = (upstreamParams?._meta?.progressToken);
         if (progressToken !== undefined)
@@ -82,6 +89,14 @@ class Forwarder {
                 this.runner.captureSessionId(host, route.serverName, refreshed, upstream.headers.get("mcp-session-id"));
                 responseBody = await upstream.text();
             }
+            // Pairing changed underneath us between dispatch and response. Reply
+            // with a generic error so the request doesn't hang — the agent can
+            // retry against the new pairing — but don't write the stale body or
+            // its upstream-level error, since neither applies to the new config.
+            if (this.state.configGeneration !== startGeneration) {
+                this.sendError(protocol_js_1.ErrorCode.INTERNAL, "request superseded by reconfiguration", id);
+                return;
+            }
             if (!upstream.ok) {
                 this.sendError(protocol_js_1.ErrorCode.HOST_UNREACHABLE, `host returned ${upstream.status}: ${responseBody.slice(0, 200)}`, id);
                 return;
@@ -137,6 +152,13 @@ class Forwarder {
             this.writeOut(JSON.stringify(parsed));
         }
         catch (err) {
+            // Same supersession guard as the success path: if the abort/error
+            // raced a re-pair, the agent should see "superseded" rather than the
+            // raw transport error from a pairing that no longer exists.
+            if (this.state.configGeneration !== startGeneration) {
+                this.sendError(protocol_js_1.ErrorCode.INTERNAL, "request superseded by reconfiguration", id);
+                return;
+            }
             this.sendError(protocol_js_1.ErrorCode.HOST_UNREACHABLE, err.message, id);
         }
         finally {

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?: {
@@ -40,9 +42,9 @@ export declare class RequestHandlers {
         argument?: unknown;
     }): Promise<void>;
     handleToolDispatch(id: string | number, params: {
-        name: string;
+        name?: string;
         arguments?: Record<string, unknown>;
         _meta?: unknown;
-    }): Promise<void>;
+    } | undefined): Promise<void>;
     handleClientNotification(method: string, params: Record<string, unknown>): Promise<void>;
 }

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;
@@ -241,7 +274,12 @@ class RequestHandlers {
         });
     }
     async handleToolDispatch(id, params) {
-        if (params.name === "configure") {
+        if (!params || typeof params.name !== "string") {
+            this.sendError(protocol_js_1.ErrorCode.INVALID_PARAMS, "name is required", id);
+            return;
+        }
+        const toolName = params.name;
+        if (toolName === "configure") {
             let text;
             try {
                 text = await this.pairing.handleConfigure();
@@ -253,18 +291,36 @@ 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;
         }
-        const route = this.state.toolRoute.get(params.name);
+        const route = this.state.toolRoute.get(toolName);
         if (!route || !(0, filtering_js_1.isServerSelected)(this.state.config, route.hostId, route.serverName)) {
-            this.sendError(protocol_js_1.ErrorCode.INVALID_PARAMS, `Unknown tool: ${params.name}`, id);
+            this.sendError(protocol_js_1.ErrorCode.INVALID_PARAMS, `Unknown tool: ${toolName}`, id);
             return;
         }
         // selectedTools is a tool-level filter on top of the server-level gate.
-        if (this.state.config.selectedTools !== undefined && !this.state.config.selectedTools.includes(params.name)) {
-            this.sendError(protocol_js_1.ErrorCode.INVALID_PARAMS, `Unknown tool: ${params.name}`, id);
+        if (this.state.config.selectedTools !== undefined && !this.state.config.selectedTools.includes(toolName)) {
+            this.sendError(protocol_js_1.ErrorCode.INVALID_PARAMS, `Unknown tool: ${toolName}`, id);
             return;
         }
         // Preserve `_meta` so the upstream server still sees the agent's

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/runtime/sse.js

@@ -132,6 +132,12 @@ class SseReader {
             this.cb.onUpstreamRequest(host, name, msg);
             return;
         }
+        // Symmetric with server.ts: an upstream "request" with id:null can't
+        // be answered (the bridge keys responses by id), so drop rather than
+        // forwarding it to the agent as if it were a notification — that
+        // would silently re-cast a request the upstream expects a response to.
+        if (hasMethod && msg.id === null)
+            return;
         if (!hasMethod)
             return; // stray response — not expected on this stream
         // Notifications: list_changed events trigger a cache refresh BEFORE

package/dist/proxy/runtime/upstream-bridge.js

@@ -106,21 +106,27 @@ class UpstreamBridge {
             const host = hosts.get(ctx.hostId);
             if (!host)
                 return;
+            // Teardown courtesy — share the DELETE budget, not the 5-min tool
+            // budget. A blackholed host would otherwise stall closeAllSessions
+            // (re-pair, rollback, SIGTERM shutdown) until TOOL_FORWARD_TIMEOUT_MS.
+            // The DELETE that follows reaps the session anyway; if this courtesy
+            // doesn't land quickly the upstream's own UPSTREAM_REQUEST_TIMEOUT_MS
+            // catches the orphaned child.
             return this.postResponse(host, ctx.serverName, ctx.sessionId, {
                 jsonrpc: "2.0",
                 id: ctx.originalId,
                 error: { code: protocol_js_1.ErrorCode.INTERNAL, message: "proxy reconfigured before client responded" },
-            });
+            }, constants_js_1.SESSION_DELETE_TIMEOUT_MS);
         }));
     }
-    async postResponse(host, serverName, sessionId, body) {
+    async postResponse(host, serverName, sessionId, body, timeoutMs = constants_js_1.TOOL_FORWARD_TIMEOUT_MS) {
         const target = `${host.config.tunnelUrl}/servers/${serverName}`;
         const headers = { ...this.hostHeaders(host.config), "Mcp-Session-Id": sessionId };
         try {
             const resp = await fetch(target, {
                 method: "POST",
                 headers,
-                signal: (0, fetch_timeout_js_1.timeoutSignal)(constants_js_1.TOOL_FORWARD_TIMEOUT_MS),
+                signal: (0, fetch_timeout_js_1.timeoutSignal)(timeoutMs),
                 body: JSON.stringify(body),
             });
             this.captureSessionId(host, serverName, resp.headers.get("mcp-session-id"));

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();
@@ -120,6 +122,16 @@ class ProxyServer {
             process.stdout.write((0, protocol_js_1.jsonRpcError)(protocol_js_1.ErrorCode.INVALID_REQUEST, "missing method", parsed.id ?? null) + "\n");
             return;
         }
+        // JSON-RPC 2.0 discourages id:null in requests because the spec
+        // reserves null for "id couldn't be parsed" in error responses
+        // (we use it ourselves at the PARSE_ERROR / missing-method paths).
+        // Falling through to the notification branch here would silently
+        // drop a request the agent expects an answer to; reject explicitly
+        // so the agent sees a real error instead of hanging.
+        if (parsed.id === null) {
+            process.stdout.write((0, protocol_js_1.jsonRpcError)(protocol_js_1.ErrorCode.INVALID_REQUEST, "id must not be null in a request", null) + "\n");
+            return;
+        }
         if (!hasId) {
             await this.handlers.handleClientNotification(parsed.method, parsed.params ?? {});
             return;

package/dist/shared/protocol.d.ts

@@ -50,6 +50,13 @@ export interface ServerConfig {
     env?: Record<string, string>;
     shell?: boolean;
 }
+export declare function normalizeServerConfig(raw: unknown): {
+    ok: true;
+    config: ServerConfig;
+} | {
+    ok: false;
+    reasons: string[];
+};
 export interface HostAgentConfig {
     servers: Record<string, ServerConfig>;
     host?: string;

package/dist/shared/protocol.js

@@ -6,6 +6,7 @@ exports.readBody = readBody;
 exports.getArg = getArg;
 exports.createServer = createServer;
 exports.validateServerName = validateServerName;
+exports.normalizeServerConfig = normalizeServerConfig;
 const node_fs_1 = require("node:fs");
 const node_http_1 = require("node:http");
 const node_path_1 = require("node:path");
@@ -181,3 +182,46 @@ function validateServerName(name) {
     }
     return null;
 }
+// Validates a raw ServerConfig from JSON and returns the canonical form
+// with documented defaults installed (args=[]). Every consumer of
+// ServerConfig — McpSession's spawn, the log line, future tooling — can
+// then trust the interface contract instead of re-checking shapes
+// defensively at every use site. All shape reasons are collected so a
+// misconfigured file surfaces a complete diff to fix in one error
+// message rather than one-issue-per-restart.
+function normalizeServerConfig(raw) {
+    if (!raw || typeof raw !== "object" || Array.isArray(raw)) {
+        return { ok: false, reasons: ["must be an object with at least { command }"] };
+    }
+    const r = raw;
+    const reasons = [];
+    if (typeof r.command !== "string" || r.command.length === 0) {
+        reasons.push("command must be a non-empty string");
+    }
+    if (r.args !== undefined
+        && !(Array.isArray(r.args) && r.args.every((a) => typeof a === "string"))) {
+        reasons.push("args must be an array of strings (default: [])");
+    }
+    if (r.env !== undefined) {
+        const envOk = typeof r.env === "object"
+            && r.env !== null
+            && !Array.isArray(r.env)
+            && Object.values(r.env).every((v) => typeof v === "string");
+        if (!envOk)
+            reasons.push("env must be a map of string to string (default: {})");
+    }
+    if (r.shell !== undefined && typeof r.shell !== "boolean") {
+        reasons.push("shell must be boolean (default: false)");
+    }
+    if (reasons.length > 0)
+        return { ok: false, reasons };
+    return {
+        ok: true,
+        config: {
+            command: r.command,
+            args: r.args ?? [],
+            env: r.env,
+            shell: r.shell,
+        },
+    };
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@silver886/mcp-proxy",
-  "version": "0.2.4",
+  "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,9 +57,15 @@
       "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": {
-    "build": "tsc"
+    "build": "tsc",
+    "test": "tsc --noEmit"
   }
 }