@j0hanz/filesystem-mcp 1.2.3 → 1.2.4

package/dist/cli.d.ts

@@ -5,4 +5,5 @@ export declare class CliExitError extends Error {
 export declare function parseArgs(): Promise<{
     allowedDirs: string[];
     allowCwd: boolean;
+    port: number | undefined;
 }>;

package/dist/cli.js

@@ -123,6 +123,7 @@ function createCliProgram(output) {
         .description('MCP filesystem server. Positional directories define allowed access roots.')
         .argument('[allowedDirs...]', 'Directories the MCP server can access on disk', parseAllowedDirArgument)
         .option('--allow_cwd, --allow-cwd', 'Allow the current working directory as an additional root')
+        .option('--port <number>', 'Enable HTTP transport on the given port (MCP Streamable HTTP with SSE)')
         .helpOption('-h, --help', 'Display command help')
         .version(SERVER_VERSION, '-v, --version', 'Display server version')
         .addHelpText('after', `
@@ -130,6 +131,7 @@ Examples:
   $ filesystem-mcp /path/to/allowed/dir
   $ filesystem-mcp --allow-cwd
   $ filesystem-mcp /project/src /project/tests --allow-cwd
+  $ filesystem-mcp --port 3000 /path/to/allowed/dir
 `);
     cli.allowUnknownOption(false);
     cli.allowExcessArguments(false);
@@ -171,6 +173,15 @@ function deduplicateAllowedDirectories(dirs) {
     }
     return deduplicated;
 }
+function parsePortOption(raw) {
+    if (raw === undefined)
+        return undefined;
+    const n = Number(raw);
+    if (!Number.isInteger(n) || n < 1 || n > 65535) {
+        throw new CliExitError(`Error: --port must be an integer between 1 and 65535`, 1);
+    }
+    return n;
+}
 export async function parseArgs() {
     const output = [];
     const cli = createCliProgram(output);
@@ -185,6 +196,7 @@ export async function parseArgs() {
     }
     const options = cli.opts();
     const allowCwd = options.allowCwd === true;
+    const port = parsePortOption(options.port);
     const positionals = getParsedAllowedDirs(cli);
     let allowedDirs;
     try {
@@ -195,5 +207,5 @@ export async function parseArgs() {
         throw new CliExitError(normalizeCliExitMessage(error), 1);
     }
     const deduplicatedDirs = deduplicateAllowedDirectories(allowedDirs);
-    return { allowedDirs: deduplicatedDirs, allowCwd };
+    return { allowedDirs: deduplicatedDirs, allowCwd, port };
 }

package/dist/index.js

@@ -5,9 +5,10 @@ import { DEFAULT_SEARCH_TIMEOUT_MS } from './lib/constants.js';
 import { formatUnknownErrorMessage } from './lib/errors.js';
 import { createTimedAbortSignal } from './lib/fs-helpers.js';
 import { setAllowedDirectoriesResolved } from './lib/path-validation.js';
-import { createServer, startServer } from './server.js';
+import { createServer, startHttpServer, startServer } from './server.js';
 const SHUTDOWN_TIMEOUT_MS = 5000;
 let activeServer;
+let activeHttpServer;
 let shutdownStarted = false;
 function isStdinEvent(event) {
     return event === 'end' || event === 'close';
@@ -31,6 +32,14 @@ async function shutdown(reason, exitCode = 0) {
     }, SHUTDOWN_TIMEOUT_MS);
     timer.unref();
     try {
+        if (activeHttpServer) {
+            const server = activeHttpServer;
+            await new Promise((resolve) => {
+                server.close(() => {
+                    resolve();
+                });
+            });
+        }
         if (activeServer) {
             await activeServer.close();
         }
@@ -48,9 +57,10 @@ async function shutdown(reason, exitCode = 0) {
 async function main() {
     let allowedDirs;
     let allowCwd;
+    let port;
     try {
         const parsed = await parseArgs();
-        ({ allowedDirs, allowCwd } = parsed);
+        ({ allowedDirs, allowCwd, port } = parsed);
     }
     catch (error) {
         if (error instanceof CliExitError) {
@@ -78,12 +88,20 @@ async function main() {
     else {
         console.error(`No directories specified via CLI. Will use MCP Roots${allowCwd ? ' or current working directory' : ''}.`);
     }
-    const server = await createServer({
-        allowCwd,
-        cliAllowedDirs: allowedDirs,
-    });
-    activeServer = server;
-    await startServer(server);
+    if (port !== undefined) {
+        activeHttpServer = await startHttpServer(port, {
+            allowCwd,
+            cliAllowedDirs: allowedDirs,
+        });
+    }
+    else {
+        const server = await createServer({
+            allowCwd,
+            cliAllowedDirs: allowedDirs,
+        });
+        activeServer = server;
+        await startServer(server);
+    }
 }
 registerShutdownTrigger('SIGTERM');
 registerShutdownTrigger('SIGINT');

package/dist/server/bootstrap.d.ts

@@ -1,4 +1,6 @@
+import * as http from 'node:http';
 import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
 import type { ServerOptions } from './types.js';
 export declare function createServer(options?: ServerOptions): Promise<McpServer>;
 export declare function startServer(server: McpServer): Promise<void>;
+export declare function startHttpServer(port: number, options: ServerOptions): Promise<http.Server>;

package/dist/server/bootstrap.js

@@ -1,10 +1,13 @@
 import * as fs from 'node:fs/promises';
+import * as http from 'node:http';
 import * as path from 'node:path';
+import { randomUUID } from 'node:crypto';
 import { fileURLToPath } from 'node:url';
 import { InMemoryTaskMessageQueue, InMemoryTaskStore, } from '@modelcontextprotocol/sdk/experimental/tasks/stores/in-memory.js';
 import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
 import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
-import { SetLevelRequestSchema } from '@modelcontextprotocol/sdk/types.js';
+import { StreamableHTTPServerTransport } from '@modelcontextprotocol/sdk/server/streamableHttp.js';
+import { isInitializeRequest, SetLevelRequestSchema, } from '@modelcontextprotocol/sdk/types.js';
 import { registerCompletions } from '../completions.js';
 import { formatUnknownErrorMessage } from '../lib/errors.js';
 import { createInMemoryResourceStore } from '../lib/resource-store.js';
@@ -115,3 +118,183 @@ export async function startServer(server) {
     };
     rootsManager.logMissingDirectoriesIfNeeded(server);
 }
+async function readRequestBody(req) {
+    return new Promise((resolve, reject) => {
+        const chunks = [];
+        req.on('data', (chunk) => {
+            chunks.push(chunk);
+        });
+        req.on('end', () => {
+            const raw = Buffer.concat(chunks).toString('utf-8');
+            if (!raw) {
+                resolve(undefined);
+                return;
+            }
+            try {
+                resolve(JSON.parse(raw));
+            }
+            catch {
+                resolve(undefined);
+            }
+        });
+        req.on('error', reject);
+    });
+}
+async function createHttpSession(options, sessions) {
+    const mcpServer = await createServer(options);
+    const rootsManager = getRootsManager(mcpServer);
+    rootsManager.registerHandlers(mcpServer);
+    await rootsManager.recomputeAllowedDirectories();
+    const transport = new StreamableHTTPServerTransport({
+        sessionIdGenerator: () => randomUUID(),
+        onsessioninitialized: (sessionId) => {
+            sessions.set(sessionId, { server: mcpServer, transport });
+            rootsManager.logMissingDirectoriesIfNeeded(mcpServer);
+        },
+        onsessionclosed: (sessionId) => {
+            sessions.delete(sessionId);
+        },
+    });
+    transport.onclose = () => {
+        const { sessionId } = transport;
+        if (sessionId) {
+            sessions.delete(sessionId);
+        }
+        rootsManager.destroy();
+        mcpServer.close().catch((err) => {
+            console.error('[HTTP] Error closing MCP server:', formatUnknownErrorMessage(err));
+        });
+    };
+    await mcpServer.connect(transport);
+    return { server: mcpServer, transport };
+}
+export async function startHttpServer(port, options) {
+    const sessions = new Map();
+    async function handleMcpRequest(req, res) {
+        const { method } = req;
+        const sessionId = req.headers['mcp-session-id'];
+        try {
+            if (method === 'POST') {
+                const body = await readRequestBody(req);
+                if (sessionId && sessions.has(sessionId)) {
+                    const session = sessions.get(sessionId);
+                    if (session) {
+                        await session.transport.handleRequest(req, res, body);
+                    }
+                    else {
+                        res.writeHead(400, { 'Content-Type': 'application/json' });
+                        res.end(JSON.stringify({
+                            jsonrpc: '2.0',
+                            error: {
+                                code: -32000,
+                                message: 'Bad Request: Session not found',
+                            },
+                            id: null,
+                        }));
+                    }
+                }
+                else if (!sessionId && isInitializeRequest(body)) {
+                    const { transport } = await createHttpSession(options, sessions);
+                    await transport.handleRequest(req, res, body);
+                }
+                else {
+                    res.writeHead(400, { 'Content-Type': 'application/json' });
+                    res.end(JSON.stringify({
+                        jsonrpc: '2.0',
+                        error: {
+                            code: -32000,
+                            message: 'Bad Request: No valid session ID provided',
+                        },
+                        id: null,
+                    }));
+                }
+            }
+            else if (method === 'GET') {
+                if (!sessionId || !sessions.has(sessionId)) {
+                    res.writeHead(400, { 'Content-Type': 'application/json' });
+                    res.end(JSON.stringify({
+                        jsonrpc: '2.0',
+                        error: {
+                            code: -32000,
+                            message: 'Bad Request: Invalid or missing session ID',
+                        },
+                        id: null,
+                    }));
+                    return;
+                }
+                const session = sessions.get(sessionId);
+                if (session) {
+                    await session.transport.handleRequest(req, res);
+                }
+                else {
+                    res.writeHead(400, { 'Content-Type': 'application/json' });
+                    res.end(JSON.stringify({
+                        jsonrpc: '2.0',
+                        error: { code: -32000, message: 'Bad Request: Session not found' },
+                        id: null,
+                    }));
+                }
+            }
+            else if (method === 'DELETE') {
+                if (!sessionId || !sessions.has(sessionId)) {
+                    res.writeHead(400, { 'Content-Type': 'application/json' });
+                    res.end(JSON.stringify({
+                        jsonrpc: '2.0',
+                        error: {
+                            code: -32000,
+                            message: 'Bad Request: Invalid or missing session ID',
+                        },
+                        id: null,
+                    }));
+                    return;
+                }
+                const session = sessions.get(sessionId);
+                if (session) {
+                    await session.transport.handleRequest(req, res);
+                }
+                else {
+                    res.writeHead(400, { 'Content-Type': 'application/json' });
+                    res.end(JSON.stringify({
+                        jsonrpc: '2.0',
+                        error: { code: -32000, message: 'Bad Request: Session not found' },
+                        id: null,
+                    }));
+                }
+            }
+            else {
+                res.writeHead(405, { Allow: 'GET, POST, DELETE' });
+                res.end('Method Not Allowed');
+            }
+        }
+        catch (error) {
+            console.error('[HTTP] Error handling request:', formatUnknownErrorMessage(error));
+            if (!res.headersSent) {
+                res.writeHead(500, { 'Content-Type': 'application/json' });
+                res.end(JSON.stringify({
+                    jsonrpc: '2.0',
+                    error: { code: -32603, message: 'Internal Server Error' },
+                    id: null,
+                }));
+            }
+        }
+    }
+    const httpServer = http.createServer((req, res) => {
+        const urlPath = (req.url ?? '/').split('?')[0];
+        if (urlPath === '/mcp') {
+            handleMcpRequest(req, res).catch((err) => {
+                console.error('[HTTP] Unhandled error in request handler:', formatUnknownErrorMessage(err));
+            });
+        }
+        else {
+            res.writeHead(404);
+            res.end('Not Found');
+        }
+    });
+    return new Promise((resolve, reject) => {
+        httpServer.once('error', reject);
+        httpServer.listen(port, () => {
+            console.error(`MCP HTTP server listening on port ${port}`);
+            resolve(httpServer);
+        });
+    });
+}

package/dist/server.d.ts

@@ -1,2 +1,2 @@
-export { createServer, startServer } from './server/bootstrap.js';
+export { createServer, startHttpServer, startServer } from './server/bootstrap.js';
 export type { ServerOptions } from './server/types.js';

package/dist/server.js

@@ -1 +1 @@
-export { createServer, startServer } from './server/bootstrap.js';
+export { createServer, startHttpServer, startServer } from './server/bootstrap.js';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@j0hanz/filesystem-mcp",
-  "version": "1.2.3",
+  "version": "1.2.4",
   "mcpName": "io.github.j0hanz/filesystem-mcp",
   "description": "MCP Server that enables LLMs to interact with the local filesystem.",
   "type": "module",