@eggjs/mcp-proxy-plugin 0.0.0 → 4.0.2-beta.0

package/LICENSE

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

package/dist/agent.d.ts

@@ -0,0 +1,10 @@
+import { Application } from "egg";
+
+//#region src/agent.d.ts
+declare class AppHook {
+  private readonly agent;
+  constructor(agent: Application);
+  didLoad(): Promise<void>;
+}
+//#endregion
+export { AppHook as default };

package/dist/agent.js

@@ -0,0 +1,13 @@
+//#region src/agent.ts
+var AppHook = class {
+	agent;
+	constructor(agent) {
+		this.agent = agent;
+	}
+	async didLoad() {
+		if (this.agent.mcpProxy) await this.agent.mcpProxy?.ready();
+	}
+};
+
+//#endregion
+export { AppHook as default };

package/dist/app/extend/agent.d.ts

@@ -0,0 +1,6 @@
+//#region src/app/extend/agent.d.ts
+declare const _default: {
+  mcpProxy: any;
+};
+//#endregion
+export { _default as default };

package/dist/app/extend/agent.js

@@ -0,0 +1,17 @@
+import { MCPProxyApiClient } from "../../index.js";
+
+//#region src/app/extend/agent.ts
+const MCP_PROXY = Symbol("Application#mcpProxy");
+var agent_default = { get mcpProxy() {
+	const self = this;
+	if (!self[MCP_PROXY]) self[MCP_PROXY] = new MCPProxyApiClient({
+		logger: this.logger,
+		messenger: this.messenger,
+		app: this,
+		isAgent: true
+	});
+	return self[MCP_PROXY];
+} };
+
+//#endregion
+export { agent_default as default };

package/dist/app/extend/application.d.ts

@@ -0,0 +1,6 @@
+//#region src/app/extend/application.d.ts
+declare const _default: {
+  mcpProxy: any;
+};
+//#endregion
+export { _default as default };

package/dist/app/extend/application.js

@@ -0,0 +1,16 @@
+import { MCPProxyApiClient } from "../../index.js";
+
+//#region src/app/extend/application.ts
+const MCP_PROXY = Symbol("Application#mcpProxy");
+var application_default = { get mcpProxy() {
+	const self = this;
+	if (!self[MCP_PROXY]) self[MCP_PROXY] = new MCPProxyApiClient({
+		logger: this.logger,
+		messenger: this.messenger,
+		app: this
+	});
+	return self[MCP_PROXY];
+} };
+
+//#endregion
+export { application_default as default };

package/dist/app.d.ts

@@ -0,0 +1,11 @@
+import { Application } from "egg";
+
+//#region src/app.d.ts
+declare class AppHook {
+  private readonly agent;
+  constructor(agent: Application);
+  configWillLoad(): void;
+  didLoad(): Promise<void>;
+}
+//#endregion
+export { AppHook as default };

package/dist/app.js

@@ -0,0 +1,19 @@
+import { MCPProxyHook } from "./index.js";
+import { MCPControllerRegister } from "@eggjs/controller-plugin/lib/impl/mcp/MCPControllerRegister";
+
+//#region src/app.ts
+var AppHook = class {
+	agent;
+	constructor(agent) {
+		this.agent = agent;
+	}
+	configWillLoad() {
+		MCPControllerRegister.addHook(MCPProxyHook);
+	}
+	async didLoad() {
+		if (this.agent.mcpProxy) await this.agent.mcpProxy?.ready();
+	}
+};
+
+//#endregion
+export { AppHook as default };

package/dist/config/config.default.d.ts

@@ -0,0 +1,8 @@
+//#region src/config/config.default.d.ts
+declare const _default: () => {
+  mcp: {
+    proxyPort: number;
+  };
+};
+//#endregion
+export { _default as default };

package/dist/config/config.default.js

@@ -0,0 +1,7 @@
+//#region src/config/config.default.ts
+var config_default_default = () => {
+	return { mcp: { proxyPort: 17031 } };
+};
+
+//#endregion
+export { config_default_default as default };

package/dist/index.d.ts

@@ -0,0 +1,51 @@
+import { MCPProxyDataClient } from "./lib/MCPProxyDataClient.js";
+import { MCPControllerHook } from "@eggjs/controller-plugin/lib/impl/mcp/MCPControllerRegister";
+import { MCPProtocols } from "@eggjs/tegg-types";
+import { SSEServerTransport } from "@modelcontextprotocol/sdk/server/sse.js";
+import { StreamableHTTPServerTransport } from "@modelcontextprotocol/sdk/server/streamableHttp.js";
+import { APIClientBase } from "cluster-client";
+import { Application, Context, EggLogger } from "egg";
+
+//#region src/index.d.ts
+interface MCPProxyPayload {
+  sessionId: string;
+  message: unknown;
+}
+interface ProxyMessageOptions {
+  detail: ClientDetail;
+  sessionId: string;
+  type: MCPProtocols;
+}
+interface ClientDetail {
+  pid: number;
+  port: number;
+}
+declare const MCPProxyHook: MCPControllerHook;
+declare class MCPProxyApiClient extends APIClientBase {
+  private _client;
+  private logger;
+  private proxyHandlerMap;
+  private port;
+  private app;
+  private isAgent;
+  constructor(options: {
+    logger: EggLogger;
+    messenger: any;
+    app: Application;
+    isAgent?: boolean;
+  });
+  _init(): Promise<void>;
+  setProxyHandler(type: MCPProtocols, handler: StreamableHTTPServerTransport["handleRequest"] | SSEServerTransport["handlePostMessage"]): void;
+  registerClient(sessionId: string, pid: number): Promise<void>;
+  unregisterClient(sessionId: string): Promise<void>;
+  getClient(sessionId: string): Promise<ClientDetail | undefined>;
+  proxyMessage(ctx: Context, options: ProxyMessageOptions): Promise<void>;
+  handleSseStream(ctx: Context, stream: ReadableStream<any>): void;
+  get delegates(): Record<string, string>;
+  get DataClient(): typeof MCPProxyDataClient;
+  get clusterOptions(): {
+    name: string;
+  };
+}
+//#endregion
+export { ClientDetail, MCPProxyApiClient, MCPProxyHook, MCPProxyPayload, ProxyMessageOptions };

package/dist/index.js

@@ -0,0 +1,367 @@
+import { MCPProxyDataClient } from "./lib/MCPProxyDataClient.js";
+import { MCPControllerRegister } from "@eggjs/controller-plugin/lib/impl/mcp/MCPControllerRegister";
+import http from "http";
+import cluster from "node:cluster";
+import querystring from "node:querystring";
+import { Readable } from "node:stream";
+import url from "node:url";
+import { MCPProtocols } from "@eggjs/tegg-types";
+import { SSEServerTransport } from "@modelcontextprotocol/sdk/server/sse.js";
+import { StreamableHTTPServerTransport } from "@modelcontextprotocol/sdk/server/streamableHttp.js";
+import awaitEvent from "await-event";
+import { APIClientBase } from "cluster-client";
+import contentType from "content-type";
+import { EventSourceParserStream } from "eventsource-parser/stream";
+import compose from "koa-compose";
+import getRawBody from "raw-body";
+
+//#region src/index.ts
+const MAXIMUM_MESSAGE_SIZE = "4mb";
+const IGNORE_HEADERS = [
+	"connection",
+	"upgrade",
+	"keep-alive",
+	"proxy-connection",
+	"te",
+	"trailer",
+	"transfer-encoding"
+];
+const MCPProxyHook = {
+	async preSSEInitHandle(ctx, transport, self) {
+		const id = transport.sessionId;
+		await self.app.mcpProxy.registerClient(id, process.pid);
+		self.app.mcpProxy.setProxyHandler(MCPProtocols.SSE, async (req, res) => {
+			const sessionId = querystring.parse(url.parse(req.url).query ?? "").sessionId;
+			const ctx$1 = self.app.createContext(req, res);
+			if (MCPControllerRegister.hooks.length > 0) for (const hook of MCPControllerRegister.hooks) await hook.preProxy?.(ctx$1, req, res);
+			let transport$1;
+			const existingTransport = self.transports[sessionId];
+			if (existingTransport instanceof SSEServerTransport) transport$1 = existingTransport;
+			else {
+				res.writeHead(400).end(JSON.stringify({
+					jsonrpc: "2.0",
+					error: {
+						code: -32e3,
+						message: "Bad Request: Session exists but uses a different transport protocol"
+					},
+					id: null
+				}));
+				return;
+			}
+			if (transport$1) try {
+				await self.transports[sessionId].handlePostMessage(req, res);
+			} catch (error) {
+				self.app.logger.error("Error handling MCP message", error);
+				if (!ctx$1.res.headersSent) {
+					ctx$1.status = 500;
+					ctx$1.body = {
+						jsonrpc: "2.0",
+						error: {
+							code: -32603,
+							message: `Internal error: ${error.message}`
+						},
+						id: null
+					};
+				}
+			}
+			else res.writeHead(404).end(JSON.stringify({
+				jsonrpc: "2.0",
+				error: {
+					code: -32602,
+					message: "Bad Request: No transport found for sessionId"
+				},
+				id: null
+			}));
+		});
+		ctx.res.once("close", () => {
+			delete self.transports[id];
+			const connection = self.sseConnections.get(id);
+			if (connection) {
+				clearInterval(connection.intervalId);
+				self.sseConnections.delete(id);
+			}
+			self.app.mcpProxy.unregisterClient(id);
+		});
+	},
+	async onStreamSessionInitialized(_ctx, transport, server, self) {
+		const sessionId = transport.sessionId;
+		self.streamTransports[sessionId] = transport;
+		self.mcpServerMap[sessionId] = server;
+		self.app.mcpProxy.setProxyHandler(MCPProtocols.STREAM, async (req, res) => {
+			let mw = self.app.middleware.teggCtxLifecycleMiddleware();
+			if (self.globalMiddlewares) mw = compose([mw, self.globalMiddlewares]);
+			const ctx = self.app.createContext(req, res);
+			if (MCPControllerRegister.hooks.length > 0) for (const hook of MCPControllerRegister.hooks) await hook.preProxy?.(ctx, req, res);
+			const sessionId$1 = req.headers["mcp-session-id"];
+			if (!sessionId$1) {
+				res.writeHead(500, { "content-type": "application/json" });
+				res.end(JSON.stringify({
+					jsonrpc: "2.0",
+					error: {
+						code: -32603,
+						message: "session id not have and run in proxy"
+					},
+					id: null
+				}));
+			} else {
+				let transport$1;
+				const existingTransport = self.streamTransports[sessionId$1];
+				if (existingTransport instanceof StreamableHTTPServerTransport) transport$1 = existingTransport;
+				else {
+					res.writeHead(400, { "content-type": "application/json" });
+					res.end(JSON.stringify({
+						jsonrpc: "2.0",
+						error: {
+							code: -32e3,
+							message: "Bad Request: Session exists but uses a different transport protocol"
+						},
+						id: null
+					}));
+					return;
+				}
+				if (transport$1) await self.app.ctxStorage.run(ctx, async () => {
+					await mw(ctx, async () => {
+						await transport$1.handleRequest(ctx.req, ctx.res);
+						await awaitEvent(ctx.res, "close");
+					});
+				});
+				else {
+					res.writeHead(400, { "content-type": "application/json" });
+					res.end(JSON.stringify({
+						jsonrpc: "2.0",
+						error: {
+							code: -32602,
+							message: "Bad Request: No transport found for sessionId"
+						},
+						id: null
+					}));
+				}
+			}
+		});
+		await self.app.mcpProxy.registerClient(sessionId, process.pid);
+		transport.onclose = async () => {
+			const sid = transport.sessionId;
+			if (sid && self.streamTransports[sid]) {
+				delete self.streamTransports[sid];
+				delete self.mcpServerMap[sid];
+			}
+			await self.app.mcpProxy.unregisterClient(sid);
+		};
+	},
+	async checkAndRunProxy(ctx, type, sessionId) {
+		const detail = await ctx.app.mcpProxy.getClient(sessionId);
+		if (detail?.pid !== process.pid) {
+			await ctx.app.mcpProxy.proxyMessage(ctx, {
+				detail,
+				sessionId,
+				type
+			});
+			return true;
+		}
+		return false;
+	}
+};
+var MCPProxyApiClient = class extends APIClientBase {
+	_client;
+	logger;
+	proxyHandlerMap = {};
+	port;
+	app;
+	isAgent;
+	constructor(options) {
+		super(Object.assign({}, options, { initMethod: "_init" }));
+		this.logger = options.logger;
+		this.port = 0;
+		this.app = options.app;
+		this.isAgent = !!options.isAgent;
+	}
+	async _init() {
+		if (!this.isAgent) {
+			const validProxyActions = new Set([
+				"MCP_STDIO_PROXY",
+				"MCP_SEE_PROXY",
+				"MCP_STREAM_PROXY"
+			]);
+			const server = http.createServer(async (req, res) => {
+				const type = req.headers["mcp-proxy-type"];
+				if (!type || !validProxyActions.has(type)) {
+					res.writeHead(400, { "content-type": "application/json" });
+					res.end(JSON.stringify({
+						jsonrpc: "2.0",
+						error: {
+							code: -32600,
+							message: "Invalid proxy type"
+						},
+						id: null
+					}));
+					return;
+				}
+				await this.proxyHandlerMap[type]?.(req, res);
+			});
+			this.port = this.app.config.mcp?.proxyPort + (cluster.worker?.id ?? 0);
+			await new Promise((resolve) => server.listen(this.port, () => {
+				resolve(null);
+			}));
+		}
+	}
+	setProxyHandler(type, handler) {
+		let action;
+		switch (type) {
+			case MCPProtocols.SSE:
+				action = "MCP_SEE_PROXY";
+				break;
+			case MCPProtocols.STDIO:
+				action = "MCP_STDIO_PROXY";
+				break;
+			default:
+				action = "MCP_STREAM_PROXY";
+				break;
+		}
+		this.proxyHandlerMap[action] = handler;
+	}
+	async registerClient(sessionId, pid) {
+		await this._client.registerClient(sessionId, {
+			pid,
+			port: this.port
+		});
+	}
+	async unregisterClient(sessionId) {
+		await this._client.unregisterClient(sessionId);
+	}
+	async getClient(sessionId) {
+		return this._client.getClient(sessionId);
+	}
+	async proxyMessage(ctx, options) {
+		let body;
+		const { detail, sessionId, type } = options;
+		try {
+			let encoding = "utf-8";
+			if (ctx.req.headers["content-type"]) {
+				const ct = contentType.parse(ctx.req.headers["content-type"] ?? "");
+				if (ct.type !== "application/json") throw new Error(`Unsupported content-type: ${ct}`);
+				encoding = ct.parameters.charset;
+			}
+			body = await getRawBody(ctx.req, {
+				limit: MAXIMUM_MESSAGE_SIZE,
+				encoding
+			});
+		} catch (error) {
+			this.logger.error(error);
+			ctx.res.writeHead(400).end(JSON.stringify({
+				jsonrpc: "2.0",
+				error: {
+					code: -32602,
+					message: `Bad Request: ${String(error)}`
+				},
+				id: null
+			}));
+			return;
+		}
+		try {
+			let action;
+			switch (type) {
+				case "SSE": {
+					action = "MCP_SEE_PROXY";
+					ctx.req.headers["mcp-proxy-type"] = action;
+					ctx.req.headers["mcp-proxy-sessionid"] = sessionId;
+					const resp = await fetch(`http://localhost:${detail.port}/mcp/message?sessionId=${sessionId}`, {
+						headers: ctx.req.headers,
+						body,
+						method: ctx.req.method
+					});
+					const headers = { "mcp-proxy-arg": encodeURIComponent(body.toString()) };
+					for (const [key, value] of resp.headers.entries()) {
+						if (IGNORE_HEADERS.includes(key)) continue;
+						headers[key] = value;
+					}
+					ctx.set(headers);
+					ctx.res.statusCode = resp.status;
+					ctx.res.statusMessage = resp.statusText;
+					ctx.body = await resp.text();
+					break;
+				}
+				case "STDIO":
+					action = "MCP_STDIO_PROXY";
+					ctx.req.headers["mcp-proxy-type"] = action;
+					ctx.req.headers["mcp-proxy-sessionid"] = sessionId;
+					ctx.res.writeHead(400).end(JSON.stringify({
+						jsonrpc: "2.0",
+						error: {
+							code: -32602,
+							message: "Bad Request: STDIO IS NOT IMPL"
+						},
+						id: null
+					}));
+					break;
+				default: {
+					action = "MCP_STREAM_PROXY";
+					ctx.respond = false;
+					ctx.req.headers["mcp-proxy-type"] = action;
+					ctx.req.headers["mcp-proxy-sessionid"] = sessionId;
+					const response = await fetch(`http://localhost:${detail.port}`, {
+						headers: ctx.req.headers,
+						method: ctx.req.method,
+						...ctx.req.method !== "GET" ? { body } : {}
+					});
+					const headers = { "mcp-proxy-arg": encodeURIComponent(body.toString()) };
+					for (const [key, value] of response.headers.entries()) {
+						if (IGNORE_HEADERS.includes(key)) continue;
+						headers[key] = value;
+					}
+					ctx.set(headers);
+					ctx.res.statusCode = response.status;
+					Readable.fromWeb(response.body).pipe(ctx.res);
+					break;
+				}
+			}
+		} catch (error) {
+			this.logger.error(error);
+			ctx.res.writeHead(500, { "content-type": "application/json" }).end(JSON.stringify({
+				jsonrpc: "2.0",
+				error: {
+					code: -32603,
+					message: "Internal error"
+				},
+				id: null
+			}));
+			return;
+		}
+	}
+	handleSseStream(ctx, stream) {
+		const processStream = async () => {
+			try {
+				const reader = stream.pipeThrough(new TextDecoderStream()).pipeThrough(new EventSourceParserStream()).getReader();
+				while (true) {
+					const { value: event, done } = await reader.read();
+					if (done) break;
+					let eventData = "event: message\n";
+					if (event.id) eventData += `id: ${event.id}\n`;
+					eventData += `data: ${JSON.stringify(event.data)}\n\n`;
+					ctx.res.write(eventData);
+				}
+				ctx.res.write("event: terminate");
+			} catch (error) {
+				ctx.res.statusCode = 500;
+				ctx.res.write(`see stream error ${error}`);
+				ctx.res.end();
+			}
+		};
+		processStream();
+	}
+	get delegates() {
+		return {
+			registerClient: "invoke",
+			unregisterClient: "invoke",
+			getClient: "invoke"
+		};
+	}
+	get DataClient() {
+		return MCPProxyDataClient;
+	}
+	get clusterOptions() {
+		return { name: "MCPProxy" };
+	}
+};
+
+//#endregion
+export { MCPProxyApiClient, MCPProxyHook };

package/dist/lib/MCPProxyDataClient.d.ts

@@ -0,0 +1,17 @@
+import { Base } from "sdk-base";
+import { EggLogger } from "egg";
+
+//#region src/lib/MCPProxyDataClient.d.ts
+declare class MCPProxyDataClient extends Base {
+  private readonly clients;
+  private readonly logger;
+  constructor(options: {
+    logger: EggLogger;
+  });
+  _init(): Promise<void>;
+  registerClient(sessionId: string, pid: number): Promise<void>;
+  getClient(sessionId: string): Promise<number | undefined>;
+  unregisterClient(sessionId: string): Promise<void>;
+}
+//#endregion
+export { MCPProxyDataClient };

package/dist/lib/MCPProxyDataClient.js

@@ -0,0 +1,33 @@
+import { Base } from "sdk-base";
+
+//#region src/lib/MCPProxyDataClient.ts
+var MCPProxyDataClient = class extends Base {
+	clients;
+	logger;
+	constructor(options) {
+		const superOptions = Object.assign({}, { initMethod: "_init" });
+		super(superOptions);
+		this.clients = /* @__PURE__ */ new Map();
+		this.logger = options.logger;
+	}
+	async _init() {}
+	async registerClient(sessionId, pid) {
+		if (this.clients.has(sessionId)) {
+			const oldPid = this.clients.get(sessionId);
+			this.logger.info("[MCPClientManager] duplicate register client %s new pid %s old pid", sessionId, pid, oldPid);
+			this.clients.set(sessionId, pid);
+		} else {
+			this.logger.info("[MCPClientManager] register client %s pid %s", sessionId, pid);
+			this.clients.set(sessionId, pid);
+		}
+	}
+	async getClient(sessionId) {
+		return this.clients.get(sessionId);
+	}
+	async unregisterClient(sessionId) {
+		this.clients.delete(sessionId);
+	}
+};
+
+//#endregion
+export { MCPProxyDataClient };

package/package.json

@@ -1,31 +1,84 @@
 {
   "name": "@eggjs/mcp-proxy-plugin",
-  "version": "0.0.0",
-  "description": "egg logger",
+  "version": "4.0.2-beta.0",
+  "description": "tegg mcp proxy plugin",
   "keywords": [
     "egg",
-    "logger"
+    "mcp",
+    "plugin",
+    "tegg",
+    "typescript"
   ],
-  "homepage": "https://github.com/eggjs/egg/tree/next/packages/logger",
+  "homepage": "https://github.com/eggjs/egg/tree/next/tegg/plugin/mcp-proxy",
   "bugs": {
     "url": "https://github.com/eggjs/egg/issues"
   },
-  "license": "MIT",
-  "author": "fengmk2 <fengmk2@gmail.com> (https://github.com/fengmk2)",
   "repository": {
     "type": "git",
     "url": "git+https://github.com/eggjs/egg.git",
-    "directory": "packages/logger"
+    "directory": "tegg/plugin/mcp-proxy"
+  },
+  "files": [
+    "dist"
+  ],
+  "type": "module",
+  "main": "./dist/index.js",
+  "module": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": "./dist/index.js",
+    "./agent": "./dist/agent.js",
+    "./app": "./dist/app.js",
+    "./app/extend/agent": "./dist/app/extend/agent.js",
+    "./app/extend/application": "./dist/app/extend/application.js",
+    "./config/config.default": "./dist/config/config.default.js",
+    "./lib/MCPProxyDataClient": "./dist/lib/MCPProxyDataClient.js",
+    "./package.json": "./package.json"
   },
   "publishConfig": {
     "access": "public"
   },
   "dependencies": {
+    "@modelcontextprotocol/sdk": "^1.23.0",
+    "await-event": "2",
+    "cluster-client": "^3.7.0",
+    "content-type": "^1.0.5",
+    "eventsource-parser": "^3.0.1",
+    "koa-compose": "^4.1.0",
+    "raw-body": "^2.5.2",
+    "sdk-base": "^5.0.1",
+    "@eggjs/controller-plugin": "4.0.2-beta.0",
+    "@eggjs/tegg-types": "4.0.2-beta.0"
   },
   "devDependencies": {
+    "@types/node": "^24.10.2",
+    "eventsource": "^3.0.5",
+    "typescript": "^5.9.3",
+    "@eggjs/aop-runtime": "4.0.2-beta.0",
+    "@eggjs/metadata": "4.0.2-beta.0",
+    "@eggjs/mock": "7.0.2-beta.0",
+    "@eggjs/tegg": "4.0.2-beta.0",
+    "@eggjs/tegg-config": "4.0.2-beta.0",
+    "@eggjs/tegg-plugin": "4.0.2-beta.0",
+    "egg": "4.1.2-beta.0"
+  },
+  "peerDependencies": {
+    "egg": "4.1.2-beta.0",
+    "@eggjs/tegg-plugin": "4.0.2-beta.0"
   },
   "engines": {
-    "node": ">= 22.18.0"
+    "node": ">=22.18.0"
+  },
+  "eggModule": {
+    "name": "mcpProxy"
+  },
+  "eggPlugin": {
+    "name": "mcpProxy",
+    "dependencies": [
+      "tegg"
+    ]
+  },
+  "scripts": {
+    "typecheck": "tsgo --noEmit"
   }
-}
-
+}