skybridge 0.0.0-dev.f03017e → 0.0.0-dev.f0394fc

package/dist/server/express.test.js

@@ -1,13 +1,13 @@
 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()),
 }));
 vi.mock("./viewsDevServer.js", () => ({
     viewsDevServer: (_httpServer) => ((_req, _res, next) => next()),
 }));
-const fakeServer = {};
 async function listen(app) {
     const server = http.createServer(app);
     await new Promise((resolve) => server.listen(0, resolve));
@@ -26,6 +26,153 @@ async function postMcp(port) {
 async function postApi(port) {
     return fetch(`http://localhost:${port}/api/test`, { method: "POST" });
 }
+describe("Skybridge.express", () => {
+    it("exposes a ready Express app immediately after construction", () => {
+        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("app.express.get registers a route reachable alongside /mcp", async () => {
+        const { createApp } = await import("./express.js");
+        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({ 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("app.use and app.express.use produce the same registration order", async () => {
+        const { createApp } = await import("./express.js");
+        const callsA = [];
+        const callsB = [];
+        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();
+        });
+        sA.express.use((_req, _res, next) => {
+            callsA.push("second");
+            next();
+        });
+        const sB = buildApp();
+        sB.express.use((_req, _res, next) => {
+            callsB.push("first");
+            next();
+        });
+        sB.use((_req, _res, next) => {
+            callsB.push("second");
+            next();
+        });
+        for (const s of [sA, sB]) {
+            s.express.get("/probe", (_req, res) => res.json({ ok: true }));
+            const httpServer = http.createServer();
+            await createApp({ app: s, httpServer });
+            const { port, server: listening } = await listen(s.express);
+            openServer = listening;
+            await fetch(`http://localhost:${port}/probe`);
+            listening.close();
+        }
+        expect(callsA).toEqual(["first", "second"]);
+        expect(callsB).toEqual(["first", "second"]);
+    });
+    it("useOnError still wraps thrown /mcp errors after the route is mounted", async () => {
+        const { createApp } = await import("./express.js");
+        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 = [];
+        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.
+        app.use("/mcp", () => {
+            throw new Error("boom");
+        });
+        const httpServer = http.createServer();
+        await createApp({
+            app,
+            httpServer,
+            // 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: app["errorMiddleware"],
+        });
+        const { port, server: listening } = await listen(app.express);
+        openServer = listening;
+        const res = await postMcp(port);
+        expect(seen).toEqual(["useOnError"]);
+        expect(res.status).toBe(503);
+        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");
@@ -34,14 +181,16 @@ describe("createApp", () => {
             calls.push("custom");
             next();
         };
-        const httpServer = http.createServer();
-        const app = await createApp({
-            mcpServer: fakeServer,
-            httpServer,
-            customMiddleware: [{ handlers: [mw] }],
+        const app = new Skybridge({
+            name: "t",
+            version: "0.0.0",
+            handler: (server) => server,
         });
-        const { port, server } = await listen(app);
-        openServer = server;
+        app.use(mw);
+        const httpServer = http.createServer();
+        const expressApp = await createApp({ app, httpServer });
+        const { port, server: httpListening } = await listen(expressApp);
+        openServer = httpListening;
         await postMcp(port);
         expect(calls).toEqual(["custom"]);
     });
@@ -52,14 +201,16 @@ describe("createApp", () => {
             calls.push("auth");
             next();
         };
-        const httpServer = http.createServer();
-        const app = await createApp({
-            mcpServer: fakeServer,
-            httpServer,
-            customMiddleware: [{ path: "/mcp", handlers: [mw] }],
+        const app = new Skybridge({
+            name: "t",
+            version: "0.0.0",
+            handler: (server) => server,
         });
-        const { port, server } = await listen(app);
-        openServer = server;
+        app.use("/mcp", mw);
+        const httpServer = http.createServer();
+        const expressApp = await createApp({ app, httpServer });
+        const { port, server: httpListening } = await listen(expressApp);
+        openServer = httpListening;
         await postMcp(port);
         expect(calls).toEqual(["auth"]);
     });
@@ -70,14 +221,16 @@ describe("createApp", () => {
             calls.push("reject");
             res.status(401).json({ error: "Unauthorized" });
         };
-        const httpServer = http.createServer();
-        const app = await createApp({
-            mcpServer: fakeServer,
-            httpServer,
-            customMiddleware: [{ path: "/mcp", handlers: [reject] }],
+        const app = new Skybridge({
+            name: "t",
+            version: "0.0.0",
+            handler: (server) => server,
         });
-        const { port, server } = await listen(app);
-        openServer = server;
+        app.use("/mcp", reject);
+        const httpServer = http.createServer();
+        const expressApp = await createApp({ app, httpServer });
+        const { port, server: httpListening } = await listen(expressApp);
+        openServer = httpListening;
         const res = await postMcp(port);
         expect(calls).toEqual(["reject"]);
         expect(res.status).toBe(401);
@@ -94,14 +247,17 @@ describe("createApp", () => {
             calls.push("B");
             next();
         };
-        const httpServer = http.createServer();
-        const app = await createApp({
-            mcpServer: fakeServer,
-            httpServer,
-            customMiddleware: [{ handlers: [mwA] }, { handlers: [mwB] }],
+        const app = new Skybridge({
+            name: "t",
+            version: "0.0.0",
+            handler: (server) => server,
         });
-        const { port, server } = await listen(app);
-        openServer = server;
+        app.use(mwA);
+        app.use(mwB);
+        const httpServer = http.createServer();
+        const expressApp = await createApp({ app, httpServer });
+        const { port, server: httpListening } = await listen(expressApp);
+        openServer = httpListening;
         await postMcp(port);
         expect(calls).toEqual(["A", "B"]);
     });
@@ -112,14 +268,16 @@ describe("createApp", () => {
             calls.push("api");
             next();
         };
-        const httpServer = http.createServer();
-        const app = await createApp({
-            mcpServer: fakeServer,
-            httpServer,
-            customMiddleware: [{ path: "/api", handlers: [apiMw] }],
+        const app = new Skybridge({
+            name: "t",
+            version: "0.0.0",
+            handler: (server) => server,
         });
-        const { port, server } = await listen(app);
-        openServer = server;
+        app.use("/api", apiMw);
+        const httpServer = http.createServer();
+        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);
         expect(calls).toEqual([]);
@@ -131,14 +289,16 @@ describe("createApp", () => {
         router.get("/health", (_req, res) => {
             res.json({ status: "ok" });
         });
-        const httpServer = http.createServer();
-        const app = await createApp({
-            mcpServer: fakeServer,
-            httpServer,
-            customMiddleware: [{ handlers: [router] }],
+        const app = new Skybridge({
+            name: "t",
+            version: "0.0.0",
+            handler: (server) => server,
         });
-        const { port, server } = await listen(app);
-        openServer = server;
+        app.use(router);
+        const httpServer = http.createServer();
+        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);
         expect(await res.json()).toEqual({ status: "ok" });
@@ -150,16 +310,16 @@ describe("createApp", () => {
         router.get("/data", (_req, res) => {
             res.json({ value: 42 });
         });
-        const httpServer = http.createServer();
-        const app = await createApp({
-            mcpServer: fakeServer,
-            httpServer,
-            customMiddleware: [
-                { path: "/api", handlers: [router] },
-            ],
+        const app = new Skybridge({
+            name: "t",
+            version: "0.0.0",
+            handler: (server) => server,
         });
-        const { port, server } = await listen(app);
-        openServer = server;
+        app.use("/api", router);
+        const httpServer = http.createServer();
+        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);
         expect(await res.json()).toEqual({ value: 42 });
@@ -169,14 +329,16 @@ describe("createApp", () => {
         const throwing = () => {
             throw new Error("boom");
         };
-        const httpServer = http.createServer();
-        const app = await createApp({
-            mcpServer: fakeServer,
-            httpServer,
-            customMiddleware: [{ path: "/explode", handlers: [throwing] }],
+        const app = new Skybridge({
+            name: "t",
+            version: "0.0.0",
+            handler: (server) => server,
         });
-        const { port, server } = await listen(app);
-        openServer = server;
+        app.use("/explode", throwing);
+        const httpServer = http.createServer();
+        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);
         // Server process did not crash — it still accepts connections
@@ -186,10 +348,20 @@ 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 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: fakeServer, httpServer });
-        const { port, server } = await listen(app);
-        openServer = server;
+        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);
         expect(await res.json()).toEqual({
@@ -207,14 +379,22 @@ describe("createApp", () => {
             calls.push("error-handler");
             res.status(503).json({ custom: true });
         };
+        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: fakeServer,
+        const expressApp = await createApp({
+            app,
             httpServer,
             errorMiddleware: [{ handlers: [errorHandler] }],
         });
-        const { port, server } = await listen(app);
-        openServer = server;
+        const { port, server: httpListening } = await listen(expressApp);
+        openServer = httpListening;
         const res = await postMcp(port);
         expect(calls).toEqual(["error-handler"]);
         expect(res.status).toBe(503);
@@ -230,15 +410,23 @@ describe("createApp", () => {
         const throwingApiRoute = (_req, _res, next) => {
             next(new Error("api error"));
         };
+        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: fakeServer,
+        const expressApp = await createApp({
+            app,
             httpServer,
-            customMiddleware: [{ path: "/api/test", handlers: [throwingApiRoute] }],
             errorMiddleware: [{ path: "/mcp", handlers: [mcpErrorHandler] }],
         });
-        const { port, server } = await listen(app);
-        openServer = server;
+        const { port, server: httpListening } = await listen(expressApp);
+        openServer = httpListening;
         const mcpRes = await postMcp(port);
         expect(calls).toEqual(["mcp-error-handler"]);
         expect(mcpRes.status).toBe(503);
@@ -251,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",
@@ -286,4 +474,180 @@ describe("createApp", () => {
         consoleSpy.mockRestore();
     });
 });
+describe("createApp Vercel mode", () => {
+    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 { 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 postMcp(port);
+            expect(res.status).not.toBe(404);
+        }
+        finally {
+            if (prevVercel === undefined) {
+                delete process.env.VERCEL;
+            }
+            else {
+                process.env.VERCEL = prevVercel;
+            }
+            process.env.NODE_ENV = prevEnv;
+            vi.resetModules();
+        }
+    });
+    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 { 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 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;
+            }
+            else {
+                process.env.VERCEL = prevVercel;
+            }
+            process.env.NODE_ENV = prevEnv;
+            vi.resetModules();
+        }
+    });
+});
+describe("createApp tunnel routes", () => {
+    it("proxies POST /__skybridge/tunnel to the cli control server in dev mode", async () => {
+        // Stand up a fake control listener that returns a known JSON body.
+        const control = http.createServer((_req, res) => {
+            res.writeHead(200, { "Content-Type": "application/json" });
+            res.end('{"status":"idle"}');
+        });
+        await new Promise((resolve) => control.listen(0, "127.0.0.1", resolve));
+        const controlAddr = control.address();
+        if (typeof controlAddr === "string" || controlAddr === null) {
+            control.close();
+            throw new Error("control server has no address");
+        }
+        const controlPort = controlAddr.port;
+        const prev = process.env.__TUNNEL_CONTROL_PORT;
+        process.env.__TUNNEL_CONTROL_PORT = String(controlPort);
+        try {
+            const { createApp } = await import("./express.js");
+            const app = new Skybridge({
+                name: "t",
+                version: "0.0.0",
+                handler: (server) => server,
+            });
+            const httpServer = http.createServer();
+            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",
+            });
+            expect(res.status).toBe(200);
+            expect(await res.json()).toEqual({ status: "idle" });
+        }
+        finally {
+            if (prev === undefined) {
+                delete process.env.__TUNNEL_CONTROL_PORT;
+            }
+            else {
+                process.env.__TUNNEL_CONTROL_PORT = prev;
+            }
+            await new Promise((resolve) => control.close(() => resolve()));
+        }
+    });
+    it("does not expose /__skybridge/tunnel in production mode", async () => {
+        const prevEnv = process.env.NODE_ENV;
+        process.env.NODE_ENV = "production";
+        try {
+            vi.resetModules();
+            const { createApp } = await import("./express.js");
+            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 expressApp = await createApp({ app, httpServer });
+            const { port, server } = await listen(expressApp);
+            openServer = server;
+            const res = await fetch(`http://localhost:${port}/__skybridge/tunnel`, {
+                method: "POST",
+            });
+            expect(res.status).toBe(404);
+        }
+        finally {
+            process.env.NODE_ENV = prevEnv;
+            vi.resetModules();
+        }
+    });
+});
+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