@j0hanz/filesystem-mcp 1.2.2 → 1.2.4

package/dist/server/bootstrap.js

@@ -0,0 +1,300 @@
+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 { 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';
+import { pkgInfo } from '../pkg-info.js';
+import { registerGetHelpPrompt } from '../prompts.js';
+import { registerInstructionResource, registerResultResources, } from '../resources.js';
+import { registerAllTools } from '../tools.js';
+import { withDefaultIcons } from '../tools/shared.js';
+import { buildServerCapabilities, supportsTaskToolRequests, } from './capabilities.js';
+import { createLoggingState } from './logging.js';
+import { RootsManager } from './roots-manager.js';
+const { version: SERVER_VERSION, description: SERVER_DESCRIPTION, homepage: SERVER_HOMEPAGE, } = pkgInfo;
+const rootsManagers = new WeakMap();
+function getRootsManager(server) {
+    const manager = rootsManagers.get(server);
+    if (!manager) {
+        throw new Error('Roots manager not initialized for server instance');
+    }
+    return manager;
+}
+async function loadServerInstructions() {
+    const defaultInstructions = `
+Filesystem MCP Instructions
+(Detailed instructions failed to load - check logs)
+`;
+    try {
+        const currentDir = path.dirname(fileURLToPath(import.meta.url));
+        return await fs.readFile(path.join(currentDir, '../instructions.md'), 'utf-8');
+    }
+    catch (error) {
+        console.error('[WARNING] Failed to load instructions.md:', formatUnknownErrorMessage(error));
+        return defaultInstructions;
+    }
+}
+async function getLocalIconInfo() {
+    const name = 'logo.svg';
+    const mime = 'image/svg+xml';
+    const candidates = [`../assets/${name}`, `../../assets/${name}`];
+    for (const candidate of candidates) {
+        try {
+            const iconPath = new URL(candidate, import.meta.url);
+            const buffer = await fs.readFile(iconPath);
+            return {
+                src: `data:${mime};base64,${buffer.toString('base64')}`,
+                mimeType: mime,
+            };
+        }
+        catch {
+            // Try next candidate.
+        }
+    }
+    return undefined;
+}
+export async function createServer(options = {}) {
+    const resourceStore = createInMemoryResourceStore();
+    const serverInstructions = await loadServerInstructions();
+    const localIcon = await getLocalIconInfo();
+    const taskToolSupport = supportsTaskToolRequests();
+    const serverConfig = {
+        capabilities: buildServerCapabilities({
+            enablePromptListChanged: false,
+            enableTaskToolRequests: taskToolSupport,
+        }),
+    };
+    if (taskToolSupport) {
+        serverConfig.taskStore = new InMemoryTaskStore();
+        serverConfig.taskMessageQueue = new InMemoryTaskMessageQueue();
+    }
+    if (serverInstructions) {
+        serverConfig.instructions = serverInstructions;
+    }
+    const server = new McpServer(withDefaultIcons({
+        name: 'filesystem-mcp',
+        title: 'Filesystem MCP',
+        version: SERVER_VERSION,
+        ...(SERVER_DESCRIPTION ? { description: SERVER_DESCRIPTION } : {}),
+        ...(SERVER_HOMEPAGE ? { websiteUrl: SERVER_HOMEPAGE } : {}),
+    }, localIcon), serverConfig);
+    const loggingState = createLoggingState('debug');
+    const rootsManager = new RootsManager(options, loggingState);
+    rootsManagers.set(server, rootsManager);
+    server.server.setRequestHandler(SetLevelRequestSchema, (req) => {
+        loggingState.minimumLevel = req.params.level;
+        return {};
+    });
+    registerInstructionResource(server, serverInstructions, localIcon);
+    registerGetHelpPrompt(server, serverInstructions, localIcon);
+    registerResultResources(server, resourceStore, localIcon);
+    registerCompletions(server);
+    registerAllTools(server, {
+        resourceStore,
+        isInitialized: () => rootsManager.isInitialized(),
+        ...(localIcon ? { iconInfo: localIcon } : {}),
+    });
+    return server;
+}
+export async function startServer(server) {
+    const transport = new StdioServerTransport();
+    const rootsManager = getRootsManager(server);
+    rootsManager.registerHandlers(server);
+    await rootsManager.recomputeAllowedDirectories();
+    await server.connect(transport);
+    const transportAny = transport;
+    const sdkOnClose = transportAny.onclose;
+    transportAny.onclose = () => {
+        rootsManager.destroy();
+        sdkOnClose?.();
+    };
+    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/capabilities.d.ts

@@ -0,0 +1,10 @@
+import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+export interface CapabilityOptions {
+    enablePromptListChanged?: boolean;
+    enableTaskToolRequests?: boolean;
+}
+type ServerCapabilities = NonNullable<ConstructorParameters<typeof McpServer>[1]>['capabilities'];
+type NonOptionalServerCapabilities = NonNullable<ServerCapabilities>;
+export declare function buildServerCapabilities(options?: CapabilityOptions): NonOptionalServerCapabilities;
+export declare function supportsTaskToolRequests(): boolean;
+export {};

package/dist/server/capabilities.js

@@ -0,0 +1,40 @@
+import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+let cachedTaskToolSupport;
+function detectTaskToolSupport() {
+    if (cachedTaskToolSupport !== undefined) {
+        return cachedTaskToolSupport;
+    }
+    try {
+        const probe = new McpServer({
+            name: 'filesystem-mcp-capability-probe',
+            version: '0.0.0',
+        }, { capabilities: { tools: {} } });
+        cachedTaskToolSupport =
+            typeof probe.experimental.tasks.registerToolTask === 'function';
+        void probe.close().catch(() => { });
+    }
+    catch {
+        cachedTaskToolSupport = false;
+    }
+    return cachedTaskToolSupport;
+}
+export function buildServerCapabilities(options = {}) {
+    const capabilities = {
+        logging: {},
+        resources: {},
+        tools: {},
+        prompts: options.enablePromptListChanged ? { listChanged: true } : {},
+        completions: {},
+    };
+    if (options.enableTaskToolRequests) {
+        capabilities.tasks = {
+            list: {},
+            cancel: {},
+            requests: { tools: { call: {} } },
+        };
+    }
+    return capabilities;
+}
+export function supportsTaskToolRequests() {
+    return detectTaskToolSupport();
+}

package/dist/server/logging.d.ts

@@ -0,0 +1,7 @@
+import type { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+import type { LoggingLevel } from '@modelcontextprotocol/sdk/types.js';
+export interface LoggingState {
+    minimumLevel: LoggingLevel;
+}
+export declare function createLoggingState(minimumLevel?: LoggingLevel): LoggingState;
+export declare function logToMcp(server: McpServer | undefined, level: LoggingLevel, data: string, minLevel?: LoggingLevel): void;

package/dist/server/logging.js

@@ -0,0 +1,41 @@
+import { formatUnknownErrorMessage } from '../lib/errors.js';
+import { isRecord } from '../lib/type-guards.js';
+const MCP_LOGGER_NAME = 'filesystem-mcp';
+const LOG_LEVEL_ORDER = {
+    debug: 0,
+    info: 1,
+    notice: 2,
+    warning: 3,
+    error: 4,
+    critical: 5,
+    alert: 6,
+    emergency: 7,
+};
+export function createLoggingState(minimumLevel = 'debug') {
+    return { minimumLevel };
+}
+function canSendMcpLogs(server) {
+    const capabilities = server.server.getClientCapabilities();
+    if (!isRecord(capabilities))
+        return false;
+    if (!('logging' in capabilities))
+        return false;
+    return capabilities.logging !== null;
+}
+export function logToMcp(server, level, data, minLevel = 'debug') {
+    if (LOG_LEVEL_ORDER[level] < LOG_LEVEL_ORDER[minLevel]) {
+        return;
+    }
+    if (!server || !canSendMcpLogs(server)) {
+        console.error(data);
+        return;
+    }
+    const params = {
+        level,
+        logger: MCP_LOGGER_NAME,
+        data,
+    };
+    void server.sendLoggingMessage(params).catch((error) => {
+        console.error(`Failed to send MCP log: ${level} | ${data}`, formatUnknownErrorMessage(error));
+    });
+}

package/dist/server/roots-manager.d.ts

@@ -0,0 +1,19 @@
+import type { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+import { type LoggingState } from './logging.js';
+import type { ServerOptions } from './types.js';
+export declare class RootsManager {
+    private rootsUpdateTimeout;
+    private rootDirectories;
+    private clientInitialized;
+    private readonly options;
+    readonly loggingState: LoggingState;
+    constructor(options: ServerOptions, loggingState: LoggingState);
+    isInitialized(): boolean;
+    destroy(): void;
+    logMissingDirectoriesIfNeeded(server: McpServer): void;
+    registerHandlers(server: McpServer): void;
+    recomputeAllowedDirectories(): Promise<void>;
+    private scheduleRootsUpdate;
+    private logMissingDirectories;
+    private updateRootsFromClient;
+}

package/dist/server/roots-manager.js

@@ -0,0 +1,173 @@
+import * as fs from 'node:fs/promises';
+import { InitializedNotificationSchema, RootsListChangedNotificationSchema, } from '@modelcontextprotocol/sdk/types.js';
+import { z } from 'zod';
+import { formatUnknownErrorMessage } from '../lib/errors.js';
+import { assertNotAborted, createTimedAbortSignal, withAbort, } from '../lib/fs-helpers.js';
+import { getAllowedDirectories, getValidRootDirectories, isPathWithinDirectories, normalizePath, setAllowedDirectoriesResolved, } from '../lib/path-validation.js';
+import { isRecord } from '../lib/type-guards.js';
+import { logToMcp } from './logging.js';
+const ROOTS_TIMEOUT_MS = 5000;
+const ROOTS_DEBOUNCE_MS = 100;
+function normalizeCLIDirectories(dirs) {
+    const normalized = [];
+    for (const dir of dirs) {
+        const trimmed = dir.trim();
+        if (trimmed.length === 0)
+            continue;
+        normalized.push(normalizePath(trimmed));
+    }
+    return normalized;
+}
+const RootSchema = z.strictObject({
+    uri: z.string(),
+    name: z.string().optional(),
+});
+const RootsResponseSchema = z.object({
+    roots: z.array(RootSchema).optional(),
+});
+function isRoot(value) {
+    return isRecord(value) && typeof value['uri'] === 'string';
+}
+function normalizeRoot(root) {
+    return root.name ? { uri: root.uri, name: root.name } : { uri: root.uri };
+}
+function extractRoots(value) {
+    const parsed = RootsResponseSchema.safeParse(value);
+    if (!parsed.success || !parsed.data.roots) {
+        return [];
+    }
+    const roots = [];
+    for (const root of parsed.data.roots) {
+        if (isRoot(root)) {
+            roots.push(normalizeRoot(root));
+        }
+    }
+    return roots;
+}
+async function resolveRootDirectories(roots) {
+    if (roots.length === 0)
+        return [];
+    const { signal, cleanup } = createTimedAbortSignal(undefined, ROOTS_TIMEOUT_MS);
+    try {
+        return await getValidRootDirectories(roots, signal);
+    }
+    finally {
+        cleanup();
+    }
+}
+async function isRootWithinBaseline(normalizedRoot, baseline, signal) {
+    if (!isPathWithinDirectories(normalizedRoot, baseline)) {
+        return false;
+    }
+    try {
+        assertNotAborted(signal);
+        const realPath = await withAbort(fs.realpath(normalizedRoot), signal);
+        const normalizedReal = normalizePath(realPath);
+        return isPathWithinDirectories(normalizedReal, baseline);
+    }
+    catch {
+        return false;
+    }
+}
+async function filterRootsWithinBaseline(roots, baseline, signal) {
+    const normalizedBaseline = normalizeCLIDirectories(baseline);
+    const normalizedRoots = roots.map(normalizePath);
+    if (normalizedRoots.length === 0)
+        return [];
+    const results = await Promise.allSettled(normalizedRoots.map((normalizedRoot) => isRootWithinBaseline(normalizedRoot, normalizedBaseline, signal)));
+    return normalizedRoots.filter((_, i) => {
+        const result = results[i];
+        return result?.status === 'fulfilled' && result.value;
+    });
+}
+export class RootsManager {
+    rootsUpdateTimeout;
+    rootDirectories = [];
+    clientInitialized = false;
+    options;
+    loggingState;
+    constructor(options, loggingState) {
+        this.options = options;
+        this.loggingState = loggingState;
+    }
+    isInitialized() {
+        return this.clientInitialized;
+    }
+    destroy() {
+        if (this.rootsUpdateTimeout) {
+            clearTimeout(this.rootsUpdateTimeout);
+            this.rootsUpdateTimeout = undefined;
+        }
+    }
+    logMissingDirectoriesIfNeeded(server) {
+        if (getAllowedDirectories().length === 0) {
+            this.logMissingDirectories(server);
+        }
+    }
+    registerHandlers(server) {
+        server.server.setNotificationHandler(InitializedNotificationSchema, async () => {
+            this.clientInitialized = true;
+            await this.updateRootsFromClient(server);
+        });
+        server.server.setNotificationHandler(RootsListChangedNotificationSchema, () => {
+            if (!this.clientInitialized)
+                return;
+            this.scheduleRootsUpdate(server);
+        });
+    }
+    async recomputeAllowedDirectories() {
+        const cliAllowedDirs = normalizeCLIDirectories(this.options.cliAllowedDirs ?? []);
+        const allowCwd = this.options.allowCwd === true;
+        const allowCwdDirs = allowCwd ? [normalizePath(process.cwd())] : [];
+        const baseline = [...cliAllowedDirs, ...allowCwdDirs];
+        const { signal, cleanup } = createTimedAbortSignal(undefined, ROOTS_TIMEOUT_MS);
+        try {
+            const rootsToInclude = baseline.length > 0
+                ? await filterRootsWithinBaseline(this.rootDirectories, baseline, signal)
+                : this.rootDirectories;
+            const combined = [...baseline, ...rootsToInclude];
+            await setAllowedDirectoriesResolved(combined, signal);
+        }
+        finally {
+            cleanup();
+        }
+    }
+    scheduleRootsUpdate(server) {
+        if (this.rootsUpdateTimeout) {
+            this.rootsUpdateTimeout.refresh();
+            return;
+        }
+        this.rootsUpdateTimeout = setTimeout(() => {
+            this.rootsUpdateTimeout = undefined;
+            void this.updateRootsFromClient(server);
+        }, ROOTS_DEBOUNCE_MS);
+        this.rootsUpdateTimeout.unref();
+    }
+    logMissingDirectories(server) {
+        if (this.options.allowCwd) {
+            logToMcp(server, 'notice', 'No allowed directories specified. Using the current working directory as an allowed directory.', this.loggingState.minimumLevel);
+            return;
+        }
+        logToMcp(server, 'warning', 'No allowed directories specified. Please provide directories as command-line arguments or enable --allow-cwd to use the current working directory.', this.loggingState.minimumLevel);
+    }
+    async updateRootsFromClient(server) {
+        try {
+            const clientCapabilities = server.server.getClientCapabilities();
+            if (!clientCapabilities?.roots) {
+                this.rootDirectories = [];
+                return;
+            }
+            const rootsResult = await server.server.listRoots(undefined, {
+                timeout: ROOTS_TIMEOUT_MS,
+            });
+            const roots = extractRoots(rootsResult);
+            this.rootDirectories = await resolveRootDirectories(roots);
+        }
+        catch (error) {
+            logToMcp(server, 'debug', `[DEBUG] MCP Roots protocol unavailable or failed: ${formatUnknownErrorMessage(error)}`, this.loggingState.minimumLevel);
+        }
+        finally {
+            await this.recomputeAllowedDirectories();
+        }
+    }
+}

package/dist/server/types.d.ts

@@ -0,0 +1,4 @@
+export interface ServerOptions {
+    allowCwd?: boolean;
+    cliAllowedDirs?: string[];
+}

package/dist/server/types.js

@@ -0,0 +1 @@
+export {};

package/dist/server.d.ts

@@ -1,8 +1,2 @@
-import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
-interface ServerOptions {
-    allowCwd?: boolean;
-    cliAllowedDirs?: string[];
-}
-export declare function createServer(options?: ServerOptions): Promise<McpServer>;
-export declare function startServer(server: McpServer): Promise<void>;
-export {};
+export { createServer, startHttpServer, startServer } from './server/bootstrap.js';
+export type { ServerOptions } from './server/types.js';