@agiflowai/scaffold-mcp 1.0.21 → 1.0.22

package/dist/stdio-D8getFsj.cjs

@@ -0,0 +1,350 @@
+const require_ListScaffoldingMethodsTool = require('./ListScaffoldingMethodsTool-Dnd3E5X_.cjs');
+let node_crypto = require("node:crypto");
+let __modelcontextprotocol_sdk_server_streamableHttp_js = require("@modelcontextprotocol/sdk/server/streamableHttp.js");
+let __modelcontextprotocol_sdk_types_js = require("@modelcontextprotocol/sdk/types.js");
+let express = require("express");
+express = require_ListScaffoldingMethodsTool.__toESM(express);
+let __modelcontextprotocol_sdk_server_sse_js = require("@modelcontextprotocol/sdk/server/sse.js");
+let __modelcontextprotocol_sdk_server_stdio_js = require("@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 = (0, express.default)();
+		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.default.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 && (0, __modelcontextprotocol_sdk_types_js.isInitializeRequest)(req.body)) {
+			const mcpServer = this.serverFactory();
+			transport = new __modelcontextprotocol_sdk_server_streamableHttp_js.StreamableHTTPServerTransport({
+				sessionIdGenerator: () => (0, node_crypto.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 = (0, express.default)();
+		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.default.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 __modelcontextprotocol_sdk_server_sse_js.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 __modelcontextprotocol_sdk_server_stdio_js.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
+Object.defineProperty(exports, 'HttpTransportHandler', {
+  enumerable: true,
+  get: function () {
+    return HttpTransportHandler;
+  }
+});
+Object.defineProperty(exports, 'SseTransportHandler', {
+  enumerable: true,
+  get: function () {
+    return SseTransportHandler;
+  }
+});
+Object.defineProperty(exports, 'StdioTransportHandler', {
+  enumerable: true,
+  get: function () {
+    return StdioTransportHandler;
+  }
+});

package/dist/{stdio-Boc4SGGT.mjs → tools-DRfJ2LZc.mjs}

@@ -8,12 +8,6 @@ import { jsonSchemaToZod } from "@composio/json-schema-to-zod";
 import { z } from "zod";
 import * as fs$1 from "node:fs/promises";
 import * as os$1 from "node:os";
-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/services/BoilerplateGeneratorService.ts
 /**
@@ -1524,327 +1518,4 @@ Parameters:
 };
 
 //#endregion
-//#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 { UseScaffoldMethodTool as a, GenerateFeatureScaffoldTool as c, ScaffoldGeneratorService as d, BoilerplateService as f, WriteToFileTool as i, GenerateBoilerplateTool as l, SseTransportHandler as n, UseBoilerplateTool as o, BoilerplateGeneratorService as p, HttpTransportHandler as r, ListBoilerplatesTool as s, StdioTransportHandler as t, GenerateBoilerplateFileTool as u };
+export { GenerateFeatureScaffoldTool as a, ScaffoldGeneratorService as c, ListBoilerplatesTool as i, BoilerplateService as l, UseScaffoldMethodTool as n, GenerateBoilerplateTool as o, UseBoilerplateTool as r, GenerateBoilerplateFileTool as s, WriteToFileTool as t, BoilerplateGeneratorService as u };