@agiflowai/scaffold-mcp 1.0.21 → 1.0.22

package/dist/cli.cjs

@@ -1,6 +1,7 @@
 #!/usr/bin/env node
 const require_ListScaffoldingMethodsTool = require('./ListScaffoldingMethodsTool-Dnd3E5X_.cjs');
-const require_stdio = require('./stdio-Bw7Hyv3X.cjs');
+const require_tools = require('./tools-S18iKO9I.cjs');
+const require_stdio = require('./stdio-D8getFsj.cjs');
 let node_path = require("node:path");
 node_path = require_ListScaffoldingMethodsTool.__toESM(node_path);
 let __agiflowai_aicode_utils = require("@agiflowai/aicode-utils");
@@ -12,7 +13,7 @@ let __agiflowai_coding_agent_bridge = require("@agiflowai/coding-agent-bridge");
 let __agiflowai_hooks_adapter = require("@agiflowai/hooks-adapter");
 
 //#region package.json
-var version = "1.0.20";
+var version = "1.0.21";
 
 //#endregion
 //#region src/commands/boilerplate.ts
@@ -27,7 +28,7 @@ boilerplateCommand.command("list").description("List all available boilerplate t
 			__agiflowai_aicode_utils.messages.error("Templates folder not found. Create a templates folder or specify templatesPath in toolkit.yaml");
 			process.exit(1);
 		}
-		const { boilerplates, nextCursor } = await new require_stdio.BoilerplateService(templatesDir).listBoilerplates(options.cursor);
+		const { boilerplates, nextCursor } = await new require_tools.BoilerplateService(templatesDir).listBoilerplates(options.cursor);
 		if (boilerplates.length === 0) {
 			__agiflowai_aicode_utils.messages.warning("No boilerplate templates found.");
 			return;
@@ -58,7 +59,7 @@ boilerplateCommand.command("create <boilerplateName>").description("Create a new
 			__agiflowai_aicode_utils.messages.error("Templates folder not found. Create a templates folder or specify templatesPath in toolkit.yaml");
 			process.exit(1);
 		}
-		const boilerplateService = new require_stdio.BoilerplateService(templatesDir);
+		const boilerplateService = new require_tools.BoilerplateService(templatesDir);
 		let variables = {};
 		if (options.vars) try {
 			variables = JSON.parse(options.vars);
@@ -135,7 +136,7 @@ boilerplateCommand.command("info <boilerplateName>").description("Show detailed
 			__agiflowai_aicode_utils.messages.error("Templates folder not found. Create a templates folder or specify templatesPath in toolkit.yaml");
 			process.exit(1);
 		}
-		const bp = await new require_stdio.BoilerplateService(templatesDir).getBoilerplate(boilerplateName);
+		const bp = await new require_tools.BoilerplateService(templatesDir).getBoilerplate(boilerplateName);
 		if (!bp) {
 			__agiflowai_aicode_utils.messages.error(`Boilerplate '${boilerplateName}' not found.`);
 			process.exit(1);
@@ -474,14 +475,14 @@ function createServer(options = {}) {
 	const { adminEnabled = false, isMonolith = false, promptAsSkill = false } = options;
 	const templatesPath = __agiflowai_aicode_utils.TemplatesManagerService.findTemplatesPathSync();
 	if (!templatesPath) throw new Error("Templates folder not found. Please create a \"templates\" folder in your workspace root, or specify \"templatesPath\" in toolkit.yaml to point to your templates directory.");
-	const listBoilerplatesTool = !isMonolith ? new require_stdio.ListBoilerplatesTool(templatesPath, isMonolith) : null;
-	const useBoilerplateTool = !isMonolith ? new require_stdio.UseBoilerplateTool(templatesPath, isMonolith) : null;
+	const listBoilerplatesTool = !isMonolith ? new require_tools.ListBoilerplatesTool(templatesPath, isMonolith) : null;
+	const useBoilerplateTool = !isMonolith ? new require_tools.UseBoilerplateTool(templatesPath, isMonolith) : null;
 	const listScaffoldingMethodsTool = new require_ListScaffoldingMethodsTool.ListScaffoldingMethodsTool(templatesPath, isMonolith);
-	const useScaffoldMethodTool = new require_stdio.UseScaffoldMethodTool(templatesPath, isMonolith);
-	const writeToFileTool = new require_stdio.WriteToFileTool();
-	const generateBoilerplateTool = adminEnabled ? new require_stdio.GenerateBoilerplateTool(templatesPath, isMonolith) : null;
-	const generateBoilerplateFileTool = adminEnabled ? new require_stdio.GenerateBoilerplateFileTool(templatesPath, isMonolith) : null;
-	const generateFeatureScaffoldTool = adminEnabled ? new require_stdio.GenerateFeatureScaffoldTool(templatesPath, isMonolith) : null;
+	const useScaffoldMethodTool = new require_tools.UseScaffoldMethodTool(templatesPath, isMonolith);
+	const writeToFileTool = new require_tools.WriteToFileTool();
+	const generateBoilerplateTool = adminEnabled ? new require_tools.GenerateBoilerplateTool(templatesPath, isMonolith) : null;
+	const generateBoilerplateFileTool = adminEnabled ? new require_tools.GenerateBoilerplateFileTool(templatesPath, isMonolith) : null;
+	const generateFeatureScaffoldTool = adminEnabled ? new require_tools.GenerateFeatureScaffoldTool(templatesPath, isMonolith) : null;
 	const generateBoilerplatePrompt = adminEnabled ? new GenerateBoilerplatePrompt({
 		isMonolith,
 		promptAsSkill
@@ -535,26 +536,26 @@ function createServer(options = {}) {
 	});
 	server.setRequestHandler(__modelcontextprotocol_sdk_types_js.CallToolRequestSchema, async (request) => {
 		const { name, arguments: args } = request.params;
-		if (name === require_stdio.ListBoilerplatesTool.TOOL_NAME) {
+		if (name === require_tools.ListBoilerplatesTool.TOOL_NAME) {
 			if (isMonolith || !listBoilerplatesTool) throw new Error("Boilerplate tools are not available for monolith projects");
 			return await listBoilerplatesTool.execute(args || {});
 		}
-		if (name === require_stdio.UseBoilerplateTool.TOOL_NAME) {
+		if (name === require_tools.UseBoilerplateTool.TOOL_NAME) {
 			if (isMonolith || !useBoilerplateTool) throw new Error("Boilerplate tools are not available for monolith projects");
 			return await useBoilerplateTool.execute(args || {});
 		}
 		if (name === require_ListScaffoldingMethodsTool.ListScaffoldingMethodsTool.TOOL_NAME) return await listScaffoldingMethodsTool.execute(args || {});
-		if (name === require_stdio.UseScaffoldMethodTool.TOOL_NAME) return await useScaffoldMethodTool.execute(args || {});
-		if (name === require_stdio.WriteToFileTool.TOOL_NAME) return await writeToFileTool.execute(args || {});
-		if (name === require_stdio.GenerateBoilerplateTool.TOOL_NAME) {
+		if (name === require_tools.UseScaffoldMethodTool.TOOL_NAME) return await useScaffoldMethodTool.execute(args || {});
+		if (name === require_tools.WriteToFileTool.TOOL_NAME) return await writeToFileTool.execute(args || {});
+		if (name === require_tools.GenerateBoilerplateTool.TOOL_NAME) {
 			if (!adminEnabled || !generateBoilerplateTool) throw new Error("Admin tools are not enabled. Use --admin-enable flag to enable.");
 			return await generateBoilerplateTool.execute(args);
 		}
-		if (name === require_stdio.GenerateBoilerplateFileTool.TOOL_NAME) {
+		if (name === require_tools.GenerateBoilerplateFileTool.TOOL_NAME) {
 			if (!adminEnabled || !generateBoilerplateFileTool) throw new Error("Admin tools are not enabled. Use --admin-enable flag to enable.");
 			return await generateBoilerplateFileTool.execute(args);
 		}
-		if (name === require_stdio.GenerateFeatureScaffoldTool.TOOL_NAME) {
+		if (name === require_tools.GenerateFeatureScaffoldTool.TOOL_NAME) {
 			if (!adminEnabled || !generateFeatureScaffoldTool) throw new Error("Admin tools are not enabled. Use --admin-enable flag to enable.");
 			return await generateFeatureScaffoldTool.execute(args);
 		}
@@ -906,8 +907,8 @@ const hookCommand = new commander.Command("hook").description("Execute scaffold
 		}
 		const { agent, hookMethod } = (0, __agiflowai_hooks_adapter.parseHookType)(options.type);
 		if (agent === __agiflowai_coding_agent_bridge.CLAUDE_CODE) {
-			const useScaffoldMethodModule = await Promise.resolve().then(() => require("./useScaffoldMethod-BR3ESqor.cjs"));
-			const phantomCodeCheckModule = await Promise.resolve().then(() => require("./phantomCodeCheck-DNkWyMRE.cjs"));
+			const useScaffoldMethodModule = await Promise.resolve().then(() => require("./useScaffoldMethod-CmnKY0Vu.cjs"));
+			const phantomCodeCheckModule = await Promise.resolve().then(() => require("./phantomCodeCheck-DhzeymO-.cjs"));
 			const claudeCallbacks = [];
 			if (useScaffoldMethodModule.UseScaffoldMethodHook) {
 				const hookInstance = new useScaffoldMethodModule.UseScaffoldMethodHook();
@@ -923,7 +924,7 @@ const hookCommand = new commander.Command("hook").description("Execute scaffold
 			if (claudeCallbacks.length === 0) process.exit(0);
 			await new __agiflowai_hooks_adapter.ClaudeCodeAdapter().executeMultiple(claudeCallbacks);
 		} else if (agent === __agiflowai_coding_agent_bridge.GEMINI_CLI) {
-			const useScaffoldMethodModule = await Promise.resolve().then(() => require("./useScaffoldMethod-CJG7ngkT.cjs"));
+			const useScaffoldMethodModule = await Promise.resolve().then(() => require("./useScaffoldMethod-CejnYNDD.cjs"));
 			const geminiCallbacks = [];
 			if (useScaffoldMethodModule.UseScaffoldMethodHook) {
 				const hookInstance = new useScaffoldMethodModule.UseScaffoldMethodHook();

package/dist/cli.mjs

@@ -1,6 +1,7 @@
 #!/usr/bin/env node
-import { a as UseScaffoldMethodTool, c as GenerateFeatureScaffoldTool, f as BoilerplateService, i as WriteToFileTool, l as GenerateBoilerplateTool, n as SseTransportHandler, o as UseBoilerplateTool, r as HttpTransportHandler, s as ListBoilerplatesTool, t as StdioTransportHandler, u as GenerateBoilerplateFileTool } from "./stdio-Boc4SGGT.mjs";
+import { a as GenerateFeatureScaffoldTool, i as ListBoilerplatesTool, l as BoilerplateService, n as UseScaffoldMethodTool, o as GenerateBoilerplateTool, r as UseBoilerplateTool, s as GenerateBoilerplateFileTool, t as WriteToFileTool } from "./tools-DRfJ2LZc.mjs";
 import { c as FileSystemService, i as TemplateService, n as ScaffoldingMethodsService, t as ListScaffoldingMethodsTool } from "./ListScaffoldingMethodsTool-DjhhMWjh.mjs";
+import { n as SseTransportHandler, r as HttpTransportHandler, t as StdioTransportHandler } from "./stdio-BqcCsHuC.mjs";
 import path from "node:path";
 import { ProjectConfigResolver, TemplatesManagerService, icons, messages, print, sections } from "@agiflowai/aicode-utils";
 import { z } from "zod";
@@ -11,7 +12,7 @@ import { CLAUDE_CODE, GEMINI_CLI } from "@agiflowai/coding-agent-bridge";
 import { ClaudeCodeAdapter, GeminiCliAdapter, parseHookType } from "@agiflowai/hooks-adapter";
 
 //#region package.json
-var version = "1.0.20";
+var version = "1.0.21";
 
 //#endregion
 //#region src/commands/boilerplate.ts
@@ -905,8 +906,8 @@ const hookCommand = new Command("hook").description("Execute scaffold hooks for
 		}
 		const { agent, hookMethod } = parseHookType(options.type);
 		if (agent === CLAUDE_CODE) {
-			const useScaffoldMethodModule = await import("./useScaffoldMethod-DlrzH-3H.mjs");
-			const phantomCodeCheckModule = await import("./phantomCodeCheck-BXQonrXo.mjs");
+			const useScaffoldMethodModule = await import("./useScaffoldMethod-blx199pL.mjs");
+			const phantomCodeCheckModule = await import("./phantomCodeCheck-BwQWRJ9Q.mjs");
 			const claudeCallbacks = [];
 			if (useScaffoldMethodModule.UseScaffoldMethodHook) {
 				const hookInstance = new useScaffoldMethodModule.UseScaffoldMethodHook();
@@ -922,7 +923,7 @@ const hookCommand = new Command("hook").description("Execute scaffold hooks for
 			if (claudeCallbacks.length === 0) process.exit(0);
 			await new ClaudeCodeAdapter().executeMultiple(claudeCallbacks);
 		} else if (agent === GEMINI_CLI) {
-			const useScaffoldMethodModule = await import("./useScaffoldMethod-DaAZTyIM.mjs");
+			const useScaffoldMethodModule = await import("./useScaffoldMethod-BE2tHUMc.mjs");
 			const geminiCallbacks = [];
 			if (useScaffoldMethodModule.UseScaffoldMethodHook) {
 				const hookInstance = new useScaffoldMethodModule.UseScaffoldMethodHook();

package/dist/index.cjs

@@ -1,24 +1,25 @@
 const require_ListScaffoldingMethodsTool = require('./ListScaffoldingMethodsTool-Dnd3E5X_.cjs');
-const require_stdio = require('./stdio-Bw7Hyv3X.cjs');
+const require_tools = require('./tools-S18iKO9I.cjs');
+const require_stdio = require('./stdio-D8getFsj.cjs');
 
-exports.BoilerplateGeneratorService = require_stdio.BoilerplateGeneratorService;
-exports.BoilerplateService = require_stdio.BoilerplateService;
+exports.BoilerplateGeneratorService = require_tools.BoilerplateGeneratorService;
+exports.BoilerplateService = require_tools.BoilerplateService;
 exports.FileSystemService = require_ListScaffoldingMethodsTool.FileSystemService;
-exports.GenerateBoilerplateFileTool = require_stdio.GenerateBoilerplateFileTool;
-exports.GenerateBoilerplateTool = require_stdio.GenerateBoilerplateTool;
-exports.GenerateFeatureScaffoldTool = require_stdio.GenerateFeatureScaffoldTool;
+exports.GenerateBoilerplateFileTool = require_tools.GenerateBoilerplateFileTool;
+exports.GenerateBoilerplateTool = require_tools.GenerateBoilerplateTool;
+exports.GenerateFeatureScaffoldTool = require_tools.GenerateFeatureScaffoldTool;
 exports.HttpTransportHandler = require_stdio.HttpTransportHandler;
-exports.ListBoilerplatesTool = require_stdio.ListBoilerplatesTool;
+exports.ListBoilerplatesTool = require_tools.ListBoilerplatesTool;
 exports.ListScaffoldingMethodsTool = require_ListScaffoldingMethodsTool.ListScaffoldingMethodsTool;
 exports.ScaffoldConfigLoader = require_ListScaffoldingMethodsTool.ScaffoldConfigLoader;
-exports.ScaffoldGeneratorService = require_stdio.ScaffoldGeneratorService;
+exports.ScaffoldGeneratorService = require_tools.ScaffoldGeneratorService;
 exports.ScaffoldProcessingService = require_ListScaffoldingMethodsTool.ScaffoldProcessingService;
 exports.ScaffoldService = require_ListScaffoldingMethodsTool.ScaffoldService;
 exports.ScaffoldingMethodsService = require_ListScaffoldingMethodsTool.ScaffoldingMethodsService;
 exports.SseTransportHandler = require_stdio.SseTransportHandler;
 exports.StdioTransportHandler = require_stdio.StdioTransportHandler;
 exports.TemplateService = require_ListScaffoldingMethodsTool.TemplateService;
-exports.UseBoilerplateTool = require_stdio.UseBoilerplateTool;
-exports.UseScaffoldMethodTool = require_stdio.UseScaffoldMethodTool;
+exports.UseBoilerplateTool = require_tools.UseBoilerplateTool;
+exports.UseScaffoldMethodTool = require_tools.UseScaffoldMethodTool;
 exports.VariableReplacementService = require_ListScaffoldingMethodsTool.VariableReplacementService;
-exports.WriteToFileTool = require_stdio.WriteToFileTool;
+exports.WriteToFileTool = require_tools.WriteToFileTool;

package/dist/index.mjs

@@ -1,4 +1,5 @@
-import { a as UseScaffoldMethodTool, c as GenerateFeatureScaffoldTool, d as ScaffoldGeneratorService, f as BoilerplateService, i as WriteToFileTool, l as GenerateBoilerplateTool, n as SseTransportHandler, o as UseBoilerplateTool, p as BoilerplateGeneratorService, r as HttpTransportHandler, s as ListBoilerplatesTool, t as StdioTransportHandler, u as GenerateBoilerplateFileTool } from "./stdio-Boc4SGGT.mjs";
+import { a as GenerateFeatureScaffoldTool, c as ScaffoldGeneratorService, i as ListBoilerplatesTool, l as BoilerplateService, n as UseScaffoldMethodTool, o as GenerateBoilerplateTool, r as UseBoilerplateTool, s as GenerateBoilerplateFileTool, t as WriteToFileTool, u as BoilerplateGeneratorService } from "./tools-DRfJ2LZc.mjs";
 import { a as ScaffoldService, c as FileSystemService, i as TemplateService, n as ScaffoldingMethodsService, o as ScaffoldProcessingService, r as VariableReplacementService, s as ScaffoldConfigLoader, t as ListScaffoldingMethodsTool } from "./ListScaffoldingMethodsTool-DjhhMWjh.mjs";
+import { n as SseTransportHandler, r as HttpTransportHandler, t as StdioTransportHandler } from "./stdio-BqcCsHuC.mjs";
 
 export { BoilerplateGeneratorService, BoilerplateService, FileSystemService, GenerateBoilerplateFileTool, GenerateBoilerplateTool, GenerateFeatureScaffoldTool, HttpTransportHandler, ListBoilerplatesTool, ListScaffoldingMethodsTool, ScaffoldConfigLoader, ScaffoldGeneratorService, ScaffoldProcessingService, ScaffoldService, ScaffoldingMethodsService, SseTransportHandler, StdioTransportHandler, TemplateService, UseBoilerplateTool, UseScaffoldMethodTool, VariableReplacementService, WriteToFileTool };

package/dist/stdio-BqcCsHuC.mjs

@@ -0,0 +1,331 @@
+import { randomUUID } from "node:crypto";
+import { StreamableHTTPServerTransport } from "@modelcontextprotocol/sdk/server/streamableHttp.js";
+import { isInitializeRequest } from "@modelcontextprotocol/sdk/types.js";
+import express from "express";
+import { SSEServerTransport } from "@modelcontextprotocol/sdk/server/sse.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+
+//#region src/transports/http.ts
+/**
+* HTTP session manager
+*/
+var HttpFullSessionManager = class {
+	sessions = /* @__PURE__ */ new Map();
+	getSession(sessionId) {
+		return this.sessions.get(sessionId);
+	}
+	setSession(sessionId, transport, server) {
+		this.sessions.set(sessionId, {
+			transport,
+			server
+		});
+	}
+	deleteSession(sessionId) {
+		const session = this.sessions.get(sessionId);
+		if (session) session.server.close();
+		this.sessions.delete(sessionId);
+	}
+	hasSession(sessionId) {
+		return this.sessions.has(sessionId);
+	}
+	clear() {
+		for (const session of this.sessions.values()) session.server.close();
+		this.sessions.clear();
+	}
+};
+/**
+* HTTP transport handler using Streamable HTTP (protocol version 2025-03-26)
+* Provides stateful session management with resumability support
+*/
+var HttpTransportHandler = class {
+	serverFactory;
+	app;
+	server = null;
+	sessionManager;
+	config;
+	constructor(serverFactory, config) {
+		this.serverFactory = typeof serverFactory === "function" ? serverFactory : () => serverFactory;
+		this.app = express();
+		this.sessionManager = new HttpFullSessionManager();
+		this.config = {
+			mode: config.mode,
+			port: config.port ?? 3e3,
+			host: config.host ?? "localhost"
+		};
+		this.setupMiddleware();
+		this.setupRoutes();
+	}
+	setupMiddleware() {
+		this.app.use(express.json());
+	}
+	setupRoutes() {
+		this.app.post("/mcp", async (req, res) => {
+			await this.handlePostRequest(req, res);
+		});
+		this.app.get("/mcp", async (req, res) => {
+			await this.handleGetRequest(req, res);
+		});
+		this.app.delete("/mcp", async (req, res) => {
+			await this.handleDeleteRequest(req, res);
+		});
+		this.app.get("/health", (_req, res) => {
+			res.json({
+				status: "ok",
+				transport: "http"
+			});
+		});
+	}
+	async handlePostRequest(req, res) {
+		const sessionId = req.headers["mcp-session-id"];
+		let transport;
+		if (sessionId && this.sessionManager.hasSession(sessionId)) transport = this.sessionManager.getSession(sessionId).transport;
+		else if (!sessionId && isInitializeRequest(req.body)) {
+			const mcpServer = this.serverFactory();
+			transport = new StreamableHTTPServerTransport({
+				sessionIdGenerator: () => randomUUID(),
+				enableJsonResponse: true,
+				onsessioninitialized: (sessionId$1) => {
+					this.sessionManager.setSession(sessionId$1, transport, mcpServer);
+				}
+			});
+			transport.onclose = () => {
+				if (transport.sessionId) this.sessionManager.deleteSession(transport.sessionId);
+			};
+			await mcpServer.connect(transport);
+		} else {
+			res.status(400).json({
+				jsonrpc: "2.0",
+				error: {
+					code: -32e3,
+					message: "Bad Request: No valid session ID provided"
+				},
+				id: null
+			});
+			return;
+		}
+		await transport.handleRequest(req, res, req.body);
+	}
+	async handleGetRequest(req, res) {
+		const sessionId = req.headers["mcp-session-id"];
+		if (!sessionId || !this.sessionManager.hasSession(sessionId)) {
+			res.status(400).send("Invalid or missing session ID");
+			return;
+		}
+		await this.sessionManager.getSession(sessionId).transport.handleRequest(req, res);
+	}
+	async handleDeleteRequest(req, res) {
+		const sessionId = req.headers["mcp-session-id"];
+		if (!sessionId || !this.sessionManager.hasSession(sessionId)) {
+			res.status(400).send("Invalid or missing session ID");
+			return;
+		}
+		await this.sessionManager.getSession(sessionId).transport.handleRequest(req, res);
+		this.sessionManager.deleteSession(sessionId);
+	}
+	async start() {
+		return new Promise((resolve, reject) => {
+			try {
+				this.server = this.app.listen(this.config.port, this.config.host, () => {
+					console.error(`Scaffolding MCP server started on http://${this.config.host}:${this.config.port}/mcp`);
+					console.error(`Health check: http://${this.config.host}:${this.config.port}/health`);
+					resolve();
+				});
+				this.server.on("error", (error) => {
+					reject(error);
+				});
+			} catch (error) {
+				reject(error);
+			}
+		});
+	}
+	async stop() {
+		return new Promise((resolve, reject) => {
+			if (this.server) {
+				this.sessionManager.clear();
+				this.server.close((err) => {
+					if (err) reject(err);
+					else {
+						this.server = null;
+						resolve();
+					}
+				});
+			} else resolve();
+		});
+	}
+	getPort() {
+		return this.config.port;
+	}
+	getHost() {
+		return this.config.host;
+	}
+};
+
+//#endregion
+//#region src/transports/sse.ts
+/**
+* Session manager for SSE transports
+*/
+var SseSessionManager = class {
+	sessions = /* @__PURE__ */ new Map();
+	getSession(sessionId) {
+		return this.sessions.get(sessionId)?.transport;
+	}
+	setSession(sessionId, transport, server) {
+		this.sessions.set(sessionId, {
+			transport,
+			server
+		});
+	}
+	deleteSession(sessionId) {
+		const session = this.sessions.get(sessionId);
+		if (session) session.server.close();
+		this.sessions.delete(sessionId);
+	}
+	hasSession(sessionId) {
+		return this.sessions.has(sessionId);
+	}
+	clear() {
+		for (const session of this.sessions.values()) session.server.close();
+		this.sessions.clear();
+	}
+};
+/**
+* SSE (Server-Sent Events) transport handler
+* Legacy transport for backwards compatibility (protocol version 2024-11-05)
+* Uses separate endpoints: /sse for SSE stream (GET) and /messages for client messages (POST)
+*/
+var SseTransportHandler = class {
+	serverFactory;
+	app;
+	server = null;
+	sessionManager;
+	config;
+	constructor(serverFactory, config) {
+		this.serverFactory = typeof serverFactory === "function" ? serverFactory : () => serverFactory;
+		this.app = express();
+		this.sessionManager = new SseSessionManager();
+		this.config = {
+			mode: config.mode,
+			port: config.port ?? 3e3,
+			host: config.host ?? "localhost"
+		};
+		this.setupMiddleware();
+		this.setupRoutes();
+	}
+	setupMiddleware() {
+		this.app.use(express.json());
+	}
+	setupRoutes() {
+		this.app.get("/sse", async (req, res) => {
+			await this.handleSseConnection(req, res);
+		});
+		this.app.post("/messages", async (req, res) => {
+			await this.handlePostMessage(req, res);
+		});
+		this.app.get("/health", (_req, res) => {
+			res.json({
+				status: "ok",
+				transport: "sse"
+			});
+		});
+	}
+	async handleSseConnection(_req, res) {
+		try {
+			const mcpServer = this.serverFactory();
+			const transport = new SSEServerTransport("/messages", res);
+			this.sessionManager.setSession(transport.sessionId, transport, mcpServer);
+			res.on("close", () => {
+				this.sessionManager.deleteSession(transport.sessionId);
+			});
+			await mcpServer.connect(transport);
+			console.error(`SSE session established: ${transport.sessionId}`);
+		} catch (error) {
+			console.error("Error handling SSE connection:", error);
+			if (!res.headersSent) res.status(500).send("Internal Server Error");
+		}
+	}
+	async handlePostMessage(req, res) {
+		const sessionId = req.query.sessionId;
+		if (!sessionId) {
+			res.status(400).send("Missing sessionId query parameter");
+			return;
+		}
+		const transport = this.sessionManager.getSession(sessionId);
+		if (!transport) {
+			res.status(404).send("No transport found for sessionId");
+			return;
+		}
+		try {
+			await transport.handlePostMessage(req, res, req.body);
+		} catch (error) {
+			console.error("Error handling post message:", error);
+			if (!res.headersSent) res.status(500).send("Internal Server Error");
+		}
+	}
+	async start() {
+		return new Promise((resolve, reject) => {
+			try {
+				this.server = this.app.listen(this.config.port, this.config.host, () => {
+					console.error(`Scaffolding MCP server started with SSE transport on http://${this.config.host}:${this.config.port}`);
+					console.error(`SSE endpoint: http://${this.config.host}:${this.config.port}/sse`);
+					console.error(`Messages endpoint: http://${this.config.host}:${this.config.port}/messages`);
+					console.error(`Health check: http://${this.config.host}:${this.config.port}/health`);
+					resolve();
+				});
+				this.server.on("error", (error) => {
+					reject(error);
+				});
+			} catch (error) {
+				reject(error);
+			}
+		});
+	}
+	async stop() {
+		return new Promise((resolve, reject) => {
+			if (this.server) {
+				this.sessionManager.clear();
+				this.server.close((err) => {
+					if (err) reject(err);
+					else {
+						this.server = null;
+						resolve();
+					}
+				});
+			} else resolve();
+		});
+	}
+	getPort() {
+		return this.config.port;
+	}
+	getHost() {
+		return this.config.host;
+	}
+};
+
+//#endregion
+//#region src/transports/stdio.ts
+/**
+* Stdio transport handler for MCP server
+* Used for command-line and direct integrations
+*/
+var StdioTransportHandler = class {
+	server;
+	transport = null;
+	constructor(server) {
+		this.server = server;
+	}
+	async start() {
+		this.transport = new StdioServerTransport();
+		await this.server.connect(this.transport);
+		console.error("Scaffolding MCP server started on stdio");
+	}
+	async stop() {
+		if (this.transport) {
+			await this.transport.close();
+			this.transport = null;
+		}
+	}
+};
+
+//#endregion
+export { SseTransportHandler as n, HttpTransportHandler as r, StdioTransportHandler as t };