ninerouter-mcp 1.1.0 → 1.2.0-beta.1

package/dist/http.js

@@ -0,0 +1,197 @@
+import { createServer } from 'node:http';
+import { randomUUID } from 'node:crypto';
+import { WebStandardStreamableHTTPServerTransport, isJsonContentType, } from '@modelcontextprotocol/server';
+import { getConfig, resolveConfigPath } from './ninerouter-client.js';
+import { buildServer, registerTools } from './server.js';
+function parseHttpArgs(argv) {
+    let port = 3000;
+    let host = '127.0.0.1';
+    for (let index = 2; index < argv.length; index += 1) {
+        const argument = argv[index];
+        const nextValue = argv[index + 1];
+        if (argument === '--port' || argument === '-p') {
+            if (!nextValue)
+                throw new Error(`Missing value for ${argument}.`);
+            const parsed = Number.parseInt(nextValue, 10);
+            if (!Number.isInteger(parsed) || parsed < 0 || parsed > 65535) {
+                throw new Error(`Invalid port: ${nextValue}`);
+            }
+            port = parsed;
+            index += 1;
+        }
+        else if (argument === '--host') {
+            if (!nextValue)
+                throw new Error(`Missing value for --host.`);
+            host = nextValue;
+            index += 1;
+        }
+    }
+    return { port, host, path: '/mcp', configPath: resolveConfigPath(argv) };
+}
+function toWebRequest(req) {
+    const host = req.headers.host ?? 'localhost';
+    const protocol = 'http';
+    const url = `${protocol}://${host}${req.url ?? '/'}`;
+    const headers = new Headers();
+    for (const [name, value] of Object.entries(req.headers)) {
+        if (value === undefined)
+            continue;
+        if (Array.isArray(value)) {
+            for (const v of value)
+                headers.append(name, v);
+        }
+        else {
+            headers.set(name, value);
+        }
+    }
+    const init = { method: req.method, headers };
+    if (req.method !== 'GET' && req.method !== 'HEAD') {
+        init.body = new ReadableStream({
+            start(controller) {
+                req.on('data', (chunk) => controller.enqueue(new Uint8Array(chunk)));
+                req.on('end', () => controller.close());
+                req.on('error', (error) => controller.error(error));
+            },
+        });
+        init.duplex = 'half';
+    }
+    return new Request(url, init);
+}
+async function sendWebResponse(nodeResponse, response) {
+    applyCors(nodeResponse);
+    nodeResponse.statusCode = response.status;
+    response.headers.forEach((value, name) => {
+        if (name.toLowerCase() === 'set-cookie')
+            return;
+        if (name.toLowerCase().startsWith('access-control-'))
+            return;
+        nodeResponse.setHeader(name, value);
+    });
+    const setCookies = response.headers.getSetCookie?.() ?? [];
+    for (const cookie of setCookies)
+        nodeResponse.appendHeader('set-cookie', cookie);
+    if (response.body) {
+        const reader = response.body.getReader();
+        try {
+            while (true) {
+                const { done, value } = await reader.read();
+                if (done)
+                    break;
+                if (value)
+                    nodeResponse.write(Buffer.from(value));
+            }
+        }
+        finally {
+            reader.releaseLock();
+        }
+    }
+    nodeResponse.end();
+}
+const CORS_HEADERS = {
+    'access-control-allow-origin': '*',
+    'access-control-allow-methods': 'GET, POST, DELETE, OPTIONS',
+    'access-control-allow-headers': 'content-type, mcp-session-id, mcp-protocol-version, mcp-method, mcp-name, accept',
+    'access-control-expose-headers': 'mcp-session-id, mcp-protocol-version',
+    'access-control-max-age': '86400',
+};
+function applyCors(res) {
+    for (const [name, value] of Object.entries(CORS_HEADERS)) {
+        res.setHeader(name, value);
+    }
+}
+async function main() {
+    const args = parseHttpArgs(process.argv);
+    const config = await getConfig({ configPath: args.configPath });
+    const sessions = new Map();
+    const createSession = async () => {
+        const server = buildServer();
+        registerTools(server, config);
+        const transport = new WebStandardStreamableHTTPServerTransport({
+            sessionIdGenerator: () => randomUUID(),
+            onsessioninitialized: (sessionId) => {
+                sessions.set(sessionId, { transport, server });
+            },
+            onsessionclosed: (sessionId) => {
+                sessions.delete(sessionId);
+            },
+        });
+        await server.connect(transport);
+        return { transport, server };
+    };
+    const server = createServer(async (req, res) => {
+        const start = Date.now();
+        const log = (status) => {
+            const ms = Date.now() - start;
+            const size = Number(res.getHeader('content-length')) || 0;
+            const mcpMethod = req.headers['mcp-method'];
+            const tag = mcpMethod ? ` ${String(mcpMethod)}` : '';
+            const sid = req.headers['mcp-session-id'];
+            const sidTag = sid ? ` sid=${String(sid).slice(0, 8)}` : '';
+            process.stderr.write(`[${new Date().toISOString()}] ${req.method} ${req.url}${tag}${sidTag} → ${status} ${ms}ms ${size}B\n`);
+        };
+        try {
+            const url = new URL(req.url ?? '/', 'http://localhost');
+            if (url.pathname !== args.path) {
+                applyCors(res);
+                res.statusCode = 404;
+                res.setHeader('content-type', 'text/plain');
+                res.end('Not Found');
+                log(404);
+                return;
+            }
+            if (req.method === 'OPTIONS') {
+                applyCors(res);
+                res.statusCode = 204;
+                res.end();
+                log(204);
+                return;
+            }
+            if (req.method === 'POST' && !isJsonContentType(req.headers['content-type'] ?? null)) {
+                applyCors(res);
+                res.statusCode = 415;
+                res.setHeader('content-type', 'text/plain');
+                res.end('Content-Type must be application/json');
+                log(415);
+                return;
+            }
+            const sessionHeader = req.headers['mcp-session-id'];
+            const sessionId = typeof sessionHeader === 'string' ? sessionHeader : undefined;
+            let transport;
+            if (sessionId && sessions.has(sessionId)) {
+                transport = sessions.get(sessionId).transport;
+            }
+            else {
+                const created = await createSession();
+                transport = created.transport;
+            }
+            const request = toWebRequest(req);
+            const response = await transport.handleRequest(request);
+            await sendWebResponse(res, response);
+            log(response.status);
+        }
+        catch (error) {
+            console.error(error);
+            if (!res.headersSent) {
+                applyCors(res);
+                res.statusCode = 500;
+                res.setHeader('content-type', 'text/plain');
+            }
+            res.end('Internal Server Error');
+            log(500);
+        }
+    });
+    await new Promise((resolve) => server.listen(args.port, args.host, resolve));
+    console.error(`ninerouter-mcp HTTP listening on http://${args.host}:${args.port}${args.path}`);
+    const shutdown = () => {
+        server.close(() => {
+            for (const { transport, server: s } of sessions.values()) {
+                void transport.close();
+                void s.close?.();
+            }
+            process.exit(0);
+        });
+    };
+    process.on('SIGINT', shutdown);
+    process.on('SIGTERM', shutdown);
+}
+void main();

package/dist/index.js

@@ -1,10 +1,17 @@
 #!/usr/bin/env node
+function hasFlag(flag) {
+    return process.argv.includes(flag);
+}
 // Check if user wants to create config
-if (process.argv.includes('create-config')) {
+if (hasFlag('create-config')) {
     await import('./create-config.js');
 }
+else if (hasFlag('--http')) {
+    // Start MCP server over Streamable HTTP
+    await import('./http.js');
+}
 else {
-    // Start MCP server
+    // Start MCP server over stdio
     await import('./server.js');
 }
 export {};

package/dist/server.js

@@ -5,21 +5,28 @@ import { registerEmbeddingTools } from './tools/embeddings.js';
 import { registerMediaTools } from './tools/media.js';
 import { registerModelTools } from './tools/models.js';
 import { registerWebTools } from './tools/web.js';
-const server = new McpServer({
-    name: 'ninerouter-mcp',
-    version: '1.0.0',
-}, {
-    capabilities: {
-        tools: {},
-    },
-});
-async function main() {
-    const configPath = resolveConfigPath(process.argv);
-    const config = await getConfig({ configPath });
+export function buildServer() {
+    const server = new McpServer({
+        name: 'ninerouter-mcp',
+        version: '1.0.0',
+    }, {
+        capabilities: {
+            tools: {},
+        },
+    });
+    return server;
+}
+export function registerTools(server, config) {
     registerModelTools(server, config);
     registerWebTools(server, config);
     registerMediaTools(server, config);
     registerEmbeddingTools(server, config);
+}
+async function main() {
+    const configPath = resolveConfigPath(process.argv);
+    const config = await getConfig({ configPath });
+    const server = buildServer();
+    registerTools(server, config);
     const transport = new StdioServerTransport();
     await server.connect(transport);
 }

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "ninerouter-mcp",
-    "version": "1.1.0",
+    "version": "1.2.0-beta.1",
     "type": "module",
     "description": "MCP server for 9Router with model discovery, automatic fallback, and type-safe validation",
     "license": "Apache-2.0",
@@ -59,9 +59,11 @@
     },
     "devDependencies": {
         "@eslint/js": "^10.0.1",
+        "@semantic-release/exec": "^7.1.0",
         "@semantic-release/git": "^10.0.1",
         "@semantic-release/npm": "^13.1.5",
         "@types/node": "^22.20.0",
+        "conventional-changelog-conventionalcommits": "^9.1.0",
         "eslint": "^10.7.0",
         "husky": "^9.1.7",
         "lint-staged": "^16.0.0",