skybridge 0.0.0-dev.cb51733 → 0.0.0-dev.cb83b5b

package/dist/server/express.test.js

@@ -1,6 +1,7 @@
 import http from "node:http";
+import { Client, StreamableHTTPClientTransport, } from "@modelcontextprotocol/client";
 import { afterEach, describe, expect, it, vi } from "vitest";
-import { McpServer } from "./server.js";
+import { Skybridge } from "./app.js";
 vi.mock("@skybridge/devtools", () => ({
     devtoolsStaticServer: () => ((_req, _res, next) => next()),
 }));
@@ -25,36 +26,49 @@ async function postMcp(port) {
 async function postApi(port) {
     return fetch(`http://localhost:${port}/api/test`, { method: "POST" });
 }
-describe("McpServer.express", () => {
+describe("Skybridge.express", () => {
     it("exposes a ready Express app immediately after construction", () => {
-        const server = new McpServer({ name: "t", version: "0.0.0" });
-        expect(server.express).toBeDefined();
-        expect(typeof server.express.use).toBe("function");
-        expect(typeof server.express.get).toBe("function");
+        const app = new Skybridge({
+            name: "t",
+            version: "0.0.0",
+            handler: (server) => server,
+        });
+        expect(app.express).toBeDefined();
+        expect(typeof app.express.use).toBe("function");
+        expect(typeof app.express.get).toBe("function");
     });
-    it("server.express.get registers a route reachable alongside /mcp", async () => {
+    it("app.express.get registers a route reachable alongside /mcp", async () => {
         const { createApp } = await import("./express.js");
-        const server = new McpServer({ name: "t", version: "0.0.0" });
-        server.express.get("/health", (_req, res) => {
+        const app = new Skybridge({
+            name: "t",
+            version: "0.0.0",
+            handler: (server) => server,
+        });
+        app.express.get("/health", (_req, res) => {
             res.json({ status: "ok" });
         });
         const httpServer = http.createServer();
-        await createApp({ mcpServer: server, httpServer });
-        const { port, server: listening } = await listen(server.express);
+        await createApp({ app, httpServer });
+        const { port, server: listening } = await listen(app.express);
         openServer = listening;
         const health = await fetch(`http://localhost:${port}/health`);
         expect(health.status).toBe(200);
+        expect(health.headers.get("x-powered-by")).toBe("skybridge");
         expect(await health.json()).toEqual({ status: "ok" });
         // /mcp still works (POST returns 200/4xx, not 404)
         const mcp = await postMcp(port);
         expect(mcp.status).not.toBe(404);
     });
-    it("server.use and server.express.use produce the same registration order", async () => {
+    it("app.use and app.express.use produce the same registration order", async () => {
         const { createApp } = await import("./express.js");
         const callsA = [];
         const callsB = [];
-        const buildServer = () => new McpServer({ name: "t", version: "0.0.0" });
-        const sA = buildServer();
+        const buildApp = () => new Skybridge({
+            name: "t",
+            version: "0.0.0",
+            handler: (server) => server,
+        });
+        const sA = buildApp();
         sA.use((_req, _res, next) => {
             callsA.push("first");
             next();
@@ -63,7 +77,7 @@ describe("McpServer.express", () => {
             callsA.push("second");
             next();
         });
-        const sB = buildServer();
+        const sB = buildApp();
         sB.express.use((_req, _res, next) => {
             callsB.push("first");
             next();
@@ -75,7 +89,7 @@ describe("McpServer.express", () => {
         for (const s of [sA, sB]) {
             s.express.get("/probe", (_req, res) => res.json({ ok: true }));
             const httpServer = http.createServer();
-            await createApp({ mcpServer: s, httpServer });
+            await createApp({ app: s, httpServer });
             const { port, server: listening } = await listen(s.express);
             openServer = listening;
             await fetch(`http://localhost:${port}/probe`);
@@ -86,26 +100,32 @@ describe("McpServer.express", () => {
     });
     it("useOnError still wraps thrown /mcp errors after the route is mounted", async () => {
         const { createApp } = await import("./express.js");
-        const server = new McpServer({ name: "t", version: "0.0.0" });
+        const app = new Skybridge({
+            name: "t",
+            version: "0.0.0",
+            handler: (server) => server,
+        });
         // Register the error handler BEFORE createApp — useOnError should still
         // apply it after /mcp, so /mcp errors hit it.
         const seen = [];
-        server.useOnError((_err, _req, res, _next) => {
+        app.useOnError((_err, _req, res, _next) => {
             seen.push("useOnError");
             res.status(503).json({ from: "useOnError" });
         });
         // Force the /mcp handler to throw so the error pipeline runs.
-        vi.spyOn(server, "connectStatelessTransport").mockRejectedValue(new Error("boom"));
+        app.use("/mcp", () => {
+            throw new Error("boom");
+        });
         const httpServer = http.createServer();
         await createApp({
-            mcpServer: server,
+            app,
             httpServer,
-            // Mirror what run() does: forward the McpServer's useOnError handlers
+            // Mirror what run() does: forward the app's useOnError handlers
             // to createApp so they get applied after /mcp.
             // biome-ignore lint/complexity/useLiteralKeys: test mirrors run() internals to verify useOnError ordering
-            errorMiddleware: server["customErrorMiddleware"],
+            errorMiddleware: app["errorMiddleware"],
         });
-        const { port, server: listening } = await listen(server.express);
+        const { port, server: listening } = await listen(app.express);
         openServer = listening;
         const res = await postMcp(port);
         expect(seen).toEqual(["useOnError"]);
@@ -113,6 +133,46 @@ describe("McpServer.express", () => {
         expect(await res.json()).toEqual({ from: "useOnError" });
     });
 });
+describe("Skybridge JSON body parser options", () => {
+    const largeBody = JSON.stringify({ data: "x".repeat(200 * 1024) });
+    async function postEcho(port, body) {
+        return fetch(`http://localhost:${port}/echo`, {
+            method: "POST",
+            headers: { "Content-Type": "application/json" },
+            body,
+        });
+    }
+    it("forwards json options to express.json", async () => {
+        const app = new Skybridge({
+            name: "t",
+            version: "0.0.0",
+            json: { limit: "10mb" },
+            handler: (server) => server,
+        });
+        app.express.post("/echo", (req, res) => {
+            res.json({ received: req.body.data.length });
+        });
+        const { port, server: listening } = await listen(app.express);
+        openServer = listening;
+        const res = await postEcho(port, largeBody);
+        expect(res.status).toBe(200);
+        expect(await res.json()).toEqual({ received: 200 * 1024 });
+    });
+    it("keeps the default 100kb limit when no options are passed", async () => {
+        const app = new Skybridge({
+            name: "t",
+            version: "0.0.0",
+            handler: (server) => server,
+        });
+        app.express.post("/echo", (_req, res) => {
+            res.json({ ok: true });
+        });
+        const { port, server: listening } = await listen(app.express);
+        openServer = listening;
+        const res = await postEcho(port, largeBody);
+        expect(res.status).toBe(413);
+    });
+});
 describe("createApp", () => {
     it("runs global custom middleware before the /mcp handler", async () => {
         const { createApp } = await import("./express.js");
@@ -121,11 +181,15 @@ describe("createApp", () => {
             calls.push("custom");
             next();
         };
-        const server = new McpServer({ name: "t", version: "0.0.0" });
-        server.use(mw);
+        const app = new Skybridge({
+            name: "t",
+            version: "0.0.0",
+            handler: (server) => server,
+        });
+        app.use(mw);
         const httpServer = http.createServer();
-        const app = await createApp({ mcpServer: server, httpServer });
-        const { port, server: httpListening } = await listen(app);
+        const expressApp = await createApp({ app, httpServer });
+        const { port, server: httpListening } = await listen(expressApp);
         openServer = httpListening;
         await postMcp(port);
         expect(calls).toEqual(["custom"]);
@@ -137,11 +201,15 @@ describe("createApp", () => {
             calls.push("auth");
             next();
         };
-        const server = new McpServer({ name: "t", version: "0.0.0" });
-        server.use("/mcp", mw);
+        const app = new Skybridge({
+            name: "t",
+            version: "0.0.0",
+            handler: (server) => server,
+        });
+        app.use("/mcp", mw);
         const httpServer = http.createServer();
-        const app = await createApp({ mcpServer: server, httpServer });
-        const { port, server: httpListening } = await listen(app);
+        const expressApp = await createApp({ app, httpServer });
+        const { port, server: httpListening } = await listen(expressApp);
         openServer = httpListening;
         await postMcp(port);
         expect(calls).toEqual(["auth"]);
@@ -153,11 +221,15 @@ describe("createApp", () => {
             calls.push("reject");
             res.status(401).json({ error: "Unauthorized" });
         };
-        const server = new McpServer({ name: "t", version: "0.0.0" });
-        server.use("/mcp", reject);
+        const app = new Skybridge({
+            name: "t",
+            version: "0.0.0",
+            handler: (server) => server,
+        });
+        app.use("/mcp", reject);
         const httpServer = http.createServer();
-        const app = await createApp({ mcpServer: server, httpServer });
-        const { port, server: httpListening } = await listen(app);
+        const expressApp = await createApp({ app, httpServer });
+        const { port, server: httpListening } = await listen(expressApp);
         openServer = httpListening;
         const res = await postMcp(port);
         expect(calls).toEqual(["reject"]);
@@ -175,12 +247,16 @@ describe("createApp", () => {
             calls.push("B");
             next();
         };
-        const server = new McpServer({ name: "t", version: "0.0.0" });
-        server.use(mwA);
-        server.use(mwB);
+        const app = new Skybridge({
+            name: "t",
+            version: "0.0.0",
+            handler: (server) => server,
+        });
+        app.use(mwA);
+        app.use(mwB);
         const httpServer = http.createServer();
-        const app = await createApp({ mcpServer: server, httpServer });
-        const { port, server: httpListening } = await listen(app);
+        const expressApp = await createApp({ app, httpServer });
+        const { port, server: httpListening } = await listen(expressApp);
         openServer = httpListening;
         await postMcp(port);
         expect(calls).toEqual(["A", "B"]);
@@ -192,11 +268,15 @@ describe("createApp", () => {
             calls.push("api");
             next();
         };
-        const server = new McpServer({ name: "t", version: "0.0.0" });
-        server.use("/api", apiMw);
+        const app = new Skybridge({
+            name: "t",
+            version: "0.0.0",
+            handler: (server) => server,
+        });
+        app.use("/api", apiMw);
         const httpServer = http.createServer();
-        const app = await createApp({ mcpServer: server, httpServer });
-        const { port, server: httpListening } = await listen(app);
+        const expressApp = await createApp({ app, httpServer });
+        const { port, server: httpListening } = await listen(expressApp);
         openServer = httpListening;
         // Hit /mcp — the /api middleware should NOT fire
         await postMcp(port);
@@ -209,11 +289,15 @@ describe("createApp", () => {
         router.get("/health", (_req, res) => {
             res.json({ status: "ok" });
         });
-        const server = new McpServer({ name: "t", version: "0.0.0" });
-        server.use(router);
+        const app = new Skybridge({
+            name: "t",
+            version: "0.0.0",
+            handler: (server) => server,
+        });
+        app.use(router);
         const httpServer = http.createServer();
-        const app = await createApp({ mcpServer: server, httpServer });
-        const { port, server: httpListening } = await listen(app);
+        const expressApp = await createApp({ app, httpServer });
+        const { port, server: httpListening } = await listen(expressApp);
         openServer = httpListening;
         const res = await fetch(`http://localhost:${port}/health`);
         expect(res.status).toBe(200);
@@ -226,11 +310,15 @@ describe("createApp", () => {
         router.get("/data", (_req, res) => {
             res.json({ value: 42 });
         });
-        const server = new McpServer({ name: "t", version: "0.0.0" });
-        server.use("/api", router);
+        const app = new Skybridge({
+            name: "t",
+            version: "0.0.0",
+            handler: (server) => server,
+        });
+        app.use("/api", router);
         const httpServer = http.createServer();
-        const app = await createApp({ mcpServer: server, httpServer });
-        const { port, server: httpListening } = await listen(app);
+        const expressApp = await createApp({ app, httpServer });
+        const { port, server: httpListening } = await listen(expressApp);
         openServer = httpListening;
         const res = await fetch(`http://localhost:${port}/api/data`);
         expect(res.status).toBe(200);
@@ -241,11 +329,15 @@ describe("createApp", () => {
         const throwing = () => {
             throw new Error("boom");
         };
-        const server = new McpServer({ name: "t", version: "0.0.0" });
-        server.use("/explode", throwing);
+        const app = new Skybridge({
+            name: "t",
+            version: "0.0.0",
+            handler: (server) => server,
+        });
+        app.use("/explode", throwing);
         const httpServer = http.createServer();
-        const app = await createApp({ mcpServer: server, httpServer });
-        const { port, server: httpListening } = await listen(app);
+        const expressApp = await createApp({ app, httpServer });
+        const { port, server: httpListening } = await listen(expressApp);
         openServer = httpListening;
         const res = await fetch(`http://localhost:${port}/explode`);
         expect(res.status).toBe(500);
@@ -256,14 +348,19 @@ describe("createApp", () => {
     it("returns 500 JSON-RPC error when the MCP handler throws and no error middleware is registered", async () => {
         const { createApp } = await import("./express.js");
         const consoleSpy = vi.spyOn(console, "error").mockImplementation(() => { });
-        const mcpServer = new McpServer({ name: "t", version: "0.0.0" });
-        // Force the express-level error path: make connectStatelessTransport
-        // reject so the request handler hits its try/catch and calls next(error),
-        // which lands in the default /mcp error handler.
-        vi.spyOn(mcpServer, "connectStatelessTransport").mockRejectedValue(new Error("boom"));
+        const app = new Skybridge({
+            name: "t",
+            version: "0.0.0",
+            handler: (server) => server,
+        });
+        // Force the express-level error path: make a /mcp middleware throw so the
+        // error pipeline runs and lands in the default /mcp error handler.
+        app.use("/mcp", () => {
+            throw new Error("boom");
+        });
         const httpServer = http.createServer();
-        const app = await createApp({ mcpServer, httpServer });
-        const { port, server: httpListening } = await listen(app);
+        const expressApp = await createApp({ app, httpServer });
+        const { port, server: httpListening } = await listen(expressApp);
         openServer = httpListening;
         const res = await postMcp(port);
         expect(res.status).toBe(500);
@@ -282,15 +379,21 @@ describe("createApp", () => {
             calls.push("error-handler");
             res.status(503).json({ custom: true });
         };
-        const mcpServer = new McpServer({ name: "t", version: "0.0.0" });
-        vi.spyOn(mcpServer, "connectStatelessTransport").mockRejectedValue(new Error("boom"));
+        const app = new Skybridge({
+            name: "t",
+            version: "0.0.0",
+            handler: (server) => server,
+        });
+        app.use("/mcp", () => {
+            throw new Error("boom");
+        });
         const httpServer = http.createServer();
-        const app = await createApp({
-            mcpServer,
+        const expressApp = await createApp({
+            app,
             httpServer,
             errorMiddleware: [{ handlers: [errorHandler] }],
         });
-        const { port, server: httpListening } = await listen(app);
+        const { port, server: httpListening } = await listen(expressApp);
         openServer = httpListening;
         const res = await postMcp(port);
         expect(calls).toEqual(["error-handler"]);
@@ -307,16 +410,22 @@ describe("createApp", () => {
         const throwingApiRoute = (_req, _res, next) => {
             next(new Error("api error"));
         };
-        const mcpServer = new McpServer({ name: "t", version: "0.0.0" });
-        vi.spyOn(mcpServer, "connectStatelessTransport").mockRejectedValue(new Error("boom"));
-        mcpServer.use("/api/test", throwingApiRoute);
+        const app = new Skybridge({
+            name: "t",
+            version: "0.0.0",
+            handler: (server) => server,
+        });
+        app.use("/mcp", () => {
+            throw new Error("boom");
+        });
+        app.use("/api/test", throwingApiRoute);
         const httpServer = http.createServer();
-        const app = await createApp({
-            mcpServer,
+        const expressApp = await createApp({
+            app,
             httpServer,
             errorMiddleware: [{ path: "/mcp", handlers: [mcpErrorHandler] }],
         });
-        const { port, server: httpListening } = await listen(app);
+        const { port, server: httpListening } = await listen(expressApp);
         openServer = httpListening;
         const mcpRes = await postMcp(port);
         expect(calls).toEqual(["mcp-error-handler"]);
@@ -330,20 +439,20 @@ describe("createApp", () => {
     });
     it("handles concurrent /mcp requests without 'Already connected to a transport'", async () => {
         const { createApp } = await import("./express.js");
-        const mcpServer = new McpServer({
-            name: "concurrent-test",
-            version: "0.0.0",
-        });
         // Slow tool: keeps the underlying transport bound long enough to overlap
         // with concurrent requests, exposing the shared-McpServer race.
-        mcpServer.registerTool({ name: "slow", description: "slow" }, async () => {
-            await new Promise((r) => setTimeout(r, 50));
-            return { content: [{ type: "text", text: "done" }] };
+        const app = new Skybridge({
+            name: "concurrent-test",
+            version: "0.0.0",
+            handler: (server) => server.registerTool({ name: "slow", description: "slow" }, async () => {
+                await new Promise((r) => setTimeout(r, 50));
+                return { content: [{ type: "text", text: "done" }] };
+            }),
         });
         const consoleSpy = vi.spyOn(console, "error").mockImplementation(() => { });
         const httpServer = http.createServer();
-        const app = await createApp({ mcpServer, httpServer });
-        const { port, server } = await listen(app);
+        const expressApp = await createApp({ app, httpServer });
+        const { port, server } = await listen(expressApp);
         openServer = server;
         const callBody = (id) => JSON.stringify({
             jsonrpc: "2.0",
@@ -366,22 +475,26 @@ describe("createApp", () => {
     });
 });
 describe("createApp Vercel mode", () => {
-    it("does not mount /assets in production when VERCEL=1", async () => {
+    it("app.run() returns the Express app without binding a port when VERCEL=1", async () => {
         const prevVercel = process.env.VERCEL;
         const prevEnv = process.env.NODE_ENV;
         process.env.VERCEL = "1";
         process.env.NODE_ENV = "production";
         try {
             vi.resetModules();
-            const { createApp } = await import("./express.js");
-            const { McpServer: Reloaded } = await import("./server.js");
-            const server = new Reloaded({ name: "t", version: "0.0.0" });
-            const httpServer = http.createServer();
-            const app = await createApp({ mcpServer: server, httpServer });
-            const { port, server: listening } = await listen(app);
+            const { Skybridge: Reloaded } = await import("./app.js");
+            const app = new Reloaded({
+                name: "t",
+                version: "0.0.0",
+                handler: (server) => server,
+            });
+            const result = await app.run();
+            expect(typeof result).toBe("function");
+            expect(result).toBe(app.express);
+            const { port, server: listening } = await listen(app.express);
             openServer = listening;
-            const res = await fetch(`http://localhost:${port}/assets/foo.js`);
-            expect(res.status).toBe(404);
+            const res = await postMcp(port);
+            expect(res.status).not.toBe(404);
         }
         finally {
             if (prevVercel === undefined) {
@@ -394,24 +507,40 @@ describe("createApp Vercel mode", () => {
             vi.resetModules();
         }
     });
-    it("server.run() returns the Express app without binding a port when VERCEL=1", async () => {
+    it("passes onMcpError to the /mcp handler when VERCEL=1", async () => {
         const prevVercel = process.env.VERCEL;
         const prevEnv = process.env.NODE_ENV;
         process.env.VERCEL = "1";
         process.env.NODE_ENV = "production";
+        const consoleSpy = vi.spyOn(console, "error").mockImplementation(() => { });
         try {
             vi.resetModules();
-            const { McpServer: Reloaded } = await import("./server.js");
-            const server = new Reloaded({ name: "t", version: "0.0.0" });
-            const result = await server.run();
-            expect(typeof result).toBe("function");
-            expect(result).toBe(server.express);
-            const { port, server: listening } = await listen(server.express);
+            const { Skybridge: Reloaded } = await import("./app.js");
+            const onMcpError = vi.fn();
+            const app = new Reloaded({
+                name: "t",
+                version: "0.0.0",
+                onMcpError,
+                handler: (server) => server,
+            });
+            await app.run();
+            const { port, server: listening } = await listen(app.express);
             openServer = listening;
-            const res = await postMcp(port);
-            expect(res.status).not.toBe(404);
+            const res = await fetch(`http://localhost:${port}/mcp`, {
+                method: "POST",
+                headers: {
+                    "content-type": "application/json",
+                    accept: "application/json, text/event-stream",
+                    "mcp-protocol-version": "client-supplied-text",
+                },
+                body: JSON.stringify({ jsonrpc: "2.0", id: 1, method: "tools/list" }),
+            });
+            expect(res.status).toBe(400);
+            expect(onMcpError).toHaveBeenCalledTimes(1);
+            expect(consoleSpy).not.toHaveBeenCalled();
         }
         finally {
+            consoleSpy.mockRestore();
             if (prevVercel === undefined) {
                 delete process.env.VERCEL;
             }
@@ -441,10 +570,14 @@ describe("createApp tunnel routes", () => {
         process.env.__TUNNEL_CONTROL_PORT = String(controlPort);
         try {
             const { createApp } = await import("./express.js");
-            const mcpServer = new McpServer({ name: "t", version: "0.0.0" });
+            const app = new Skybridge({
+                name: "t",
+                version: "0.0.0",
+                handler: (server) => server,
+            });
             const httpServer = http.createServer();
-            const app = await createApp({ mcpServer, httpServer });
-            const { port, server } = await listen(app);
+            const expressApp = await createApp({ app, httpServer });
+            const { port, server } = await listen(expressApp);
             openServer = server;
             const res = await fetch(`http://localhost:${port}/__skybridge/tunnel`, {
                 method: "POST",
@@ -468,11 +601,15 @@ describe("createApp tunnel routes", () => {
         try {
             vi.resetModules();
             const { createApp } = await import("./express.js");
-            const { McpServer: ReloadedMcpServer } = await import("./server.js");
-            const mcpServer = new ReloadedMcpServer({ name: "t", version: "0.0.0" });
+            const { Skybridge: ReloadedSkybridge } = await import("./app.js");
+            const app = new ReloadedSkybridge({
+                name: "t",
+                version: "0.0.0",
+                handler: (server) => server,
+            });
             const httpServer = http.createServer();
-            const app = await createApp({ mcpServer, httpServer });
-            const { port, server } = await listen(app);
+            const expressApp = await createApp({ app, httpServer });
+            const { port, server } = await listen(expressApp);
             openServer = server;
             const res = await fetch(`http://localhost:${port}/__skybridge/tunnel`, {
                 method: "POST",
@@ -485,4 +622,32 @@ describe("createApp tunnel routes", () => {
         }
     });
 });
+describe("createApp mount path", () => {
+    it("serves /mcp with the mount path intact on the request URL", async () => {
+        const { createApp } = await import("./express.js");
+        const app = new Skybridge({
+            name: "t",
+            version: "0.0.0",
+            handler: (server) => server.registerTool({
+                name: "echo-url",
+                description: "Echoes the request URL.",
+                inputSchema: {},
+            }, (_args, extra) => ({
+                content: [{ type: "text", text: extra.http?.req?.url ?? "" }],
+            })),
+        });
+        const httpServer = http.createServer();
+        const expressApp = await createApp({ app, httpServer });
+        const { port, server } = await listen(expressApp);
+        openServer = server;
+        const client = new Client({ name: "test-client", version: "0.0.0" });
+        await client.connect(new StreamableHTTPClientTransport(new URL(`http://localhost:${port}/mcp`)));
+        const result = (await client.callTool({
+            name: "echo-url",
+            arguments: {},
+        }));
+        await client.close();
+        expect(new URL(result.content[0]?.text ?? "").pathname).toBe("/mcp");
+    });
+});
 //# sourceMappingURL=express.test.js.map