@j0hanz/filesystem-mcp 1.1.2 → 1.2.1

package/dist/lib/path-policy.js

@@ -2,10 +2,11 @@ import * as path from 'node:path';
 import { platform } from 'node:os';
 import { SENSITIVE_FILE_ALLOWLIST, SENSITIVE_FILE_DENYLIST, } from './constants.js';
 import { ErrorCode, McpError } from './errors.js';
+import { toPosixPath } from './path-format.js';
 const IS_WINDOWS = platform() === 'win32';
 const WINDOWS_ABSOLUTE_RE = /^[a-z]:\//iu;
 function normalizePathForMatch(input) {
-    return path.normalize(input).replace(/\\/gu, '/');
+    return toPosixPath(path.normalize(input));
 }
 function normalizeForMatch(input) {
     const normalized = normalizePathForMatch(input);
@@ -23,21 +24,32 @@ function compilePatternGlobs(normalizedPattern) {
     return [...globs];
 }
 function compilePatterns(patterns) {
-    const unique = new Set(patterns
-        .map((pattern) => pattern.trim())
-        .filter((pattern) => pattern.length > 0));
-    return [...unique].map((pattern) => {
+    const unique = new Set();
+    for (const pattern of patterns) {
+        const trimmed = pattern.trim();
+        if (trimmed.length > 0) {
+            unique.add(trimmed);
+        }
+    }
+    const compiled = [];
+    for (const pattern of unique) {
         const normalized = normalizeForMatch(pattern);
         const matchesPath = normalized.includes('/');
-        return {
+        compiled.push({
             raw: normalized,
             globs: matchesPath ? compilePatternGlobs(normalized) : [normalized],
             matchesPath,
-        };
-    });
+        });
+    }
+    return compiled;
 }
 const DENY_PATTERNS = compilePatterns(SENSITIVE_FILE_DENYLIST);
 const ALLOW_PATTERNS = compilePatterns(SENSITIVE_FILE_ALLOWLIST);
+function uniquePair(primary, secondary) {
+    if (!secondary || secondary === primary)
+        return [primary];
+    return [primary, secondary];
+}
 function matchesAny(patterns, pathCandidates, nameCandidates) {
     for (const pattern of patterns) {
         const candidates = pattern.matchesPath ? pathCandidates : nameCandidates;
@@ -57,18 +69,8 @@ export function isSensitivePath(requestedPath, resolvedPath) {
     const normalizedResolved = resolvedPath
         ? normalizeForMatch(resolvedPath)
         : undefined;
-    const pathCandidates = [
-        normalizedRequested,
-        ...(normalizedResolved && normalizedResolved !== normalizedRequested
-            ? [normalizedResolved]
-            : []),
-    ];
-    const nameCandidates = [
-        path.posix.basename(normalizedRequested),
-        ...(normalizedResolved && normalizedResolved !== normalizedRequested
-            ? [path.posix.basename(normalizedResolved)]
-            : []),
-    ];
+    const pathCandidates = uniquePair(normalizedRequested, normalizedResolved);
+    const nameCandidates = uniquePair(path.posix.basename(normalizedRequested), normalizedResolved ? path.posix.basename(normalizedResolved) : undefined);
     if (matchesAny(ALLOW_PATTERNS, pathCandidates, nameCandidates)) {
         return false;
     }

package/dist/lib/path-validation.js

@@ -77,6 +77,9 @@ function stripTrailingSeparator(normalized) {
         ? normalized.slice(0, -1)
         : normalized;
 }
+function isFileSystemRootPath(normalized, root) {
+    return isSamePath(normalized, root);
+}
 function normalizeAllowedDirectory(dir) {
     const trimmed = dir.trim();
     if (trimmed.length === 0)
@@ -84,16 +87,19 @@ function normalizeAllowedDirectory(dir) {
     const normalized = normalizePath(trimmed);
     const { root } = path.parse(normalized);
     // Keep filesystem roots as-is ("/", "c:\\", "\\\\server\\share\\").
-    if (normalized === root ||
-        normalizeForComparison(normalized) === normalizeForComparison(root)) {
+    if (isFileSystemRootPath(normalized, root)) {
         return root;
     }
     return stripTrailingSeparator(normalized);
 }
 function normalizeAllowedDirectories(dirs) {
-    const normalized = dirs
-        .map(normalizeAllowedDirectory)
-        .filter((dir) => dir.length > 0);
+    const normalized = [];
+    for (const dir of dirs) {
+        const entry = normalizeAllowedDirectory(dir);
+        if (entry.length > 0) {
+            normalized.push(entry);
+        }
+    }
     // Preserve first-seen order while deduping.
     return dedupePreserveOrder(normalized);
 }
@@ -109,8 +115,8 @@ export function getAllowedDirectories() {
 }
 function getAllowedDirectoriesForRelativeResolution() {
     return allowedDirectoriesPrimary.length > 0
-        ? [...allowedDirectoriesPrimary]
-        : [...allowedDirectoriesExpanded];
+        ? allowedDirectoriesPrimary
+        : allowedDirectoriesExpanded;
 }
 function isPathInsideDirectory(normalizedDirectory, normalizedCandidate) {
     const root = normalizeForComparison(normalizedDirectory);

package/dist/lib/resource-store.d.ts

@@ -4,6 +4,8 @@ export interface TextResourceEntry {
     mimeType: string;
     text: string;
     hash: string;
+    size: number;
+    storedAt: string;
 }
 export interface ResourceStore {
     putText(params: {

package/dist/lib/resource-store.js

@@ -11,12 +11,24 @@ function estimateBytes(text) {
 function computeSha256(text) {
     return hash('sha256', text, 'hex');
 }
+function createTextEntry(params) {
+    return {
+        uri: params.uri,
+        name: params.name,
+        mimeType: params.mimeType,
+        text: params.text,
+        hash: computeSha256(params.text),
+        size: estimateBytes(params.text),
+        storedAt: new Date().toISOString(),
+    };
+}
 export function createInMemoryResourceStore(options = {}) {
     const resolved = {
         ...DEFAULT_RESOURCE_STORE_OPTIONS,
         ...options,
     };
     const byUri = new Map();
+    const byHashIndex = new Map(); // sha256hex → uri
     let totalBytes = 0;
     function evictOldest() {
         const first = byUri.keys().next();
@@ -26,8 +38,9 @@ export function createInMemoryResourceStore(options = {}) {
         const existing = byUri.get(uri);
         if (!existing)
             return;
-        totalBytes -= estimateBytes(existing.text);
+        totalBytes -= existing.size;
         byUri.delete(uri);
+        byHashIndex.delete(existing.hash);
     }
     function enforceLimits() {
         while (byUri.size > resolved.maxEntries)
@@ -44,17 +57,24 @@ export function createInMemoryResourceStore(options = {}) {
         if (entryBytes > resolved.maxEntryBytes) {
             throw new McpError(ErrorCode.E_TOO_LARGE, `Resource too large to cache (${entryBytes} bytes)`);
         }
+        const contentHash = computeSha256(params.text);
+        const existingUri = byHashIndex.get(contentHash);
+        if (existingUri !== undefined) {
+            const cached = byUri.get(existingUri);
+            if (cached !== undefined) {
+                return cached;
+            }
+        }
         const id = randomUUID();
         const uri = `filesystem-mcp://result/${id}`;
-        const hash = computeSha256(params.text);
-        const entry = {
+        const entry = createTextEntry({
             uri,
             name: params.name,
             mimeType,
             text: params.text,
-            hash,
-        };
+        });
         byUri.set(uri, entry);
+        byHashIndex.set(contentHash, uri);
         totalBytes += entryBytes;
         enforceLimits();
         if (!byUri.has(uri)) {
@@ -71,6 +91,7 @@ export function createInMemoryResourceStore(options = {}) {
     }
     function clear() {
         byUri.clear();
+        byHashIndex.clear();
         totalBytes = 0;
     }
     return { putText, getText, clear };

package/dist/lib/type-guards.d.ts

@@ -0,0 +1 @@
+export declare function isRecord(value: unknown): value is Record<string, unknown>;

package/dist/lib/type-guards.js

@@ -0,0 +1,3 @@
+export function isRecord(value) {
+    return value !== null && typeof value === 'object';
+}

package/dist/prompts.d.ts

@@ -1,7 +1,3 @@
 import type { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
-interface IconInfo {
-    src: string;
-    mimeType: string;
-}
+import { type IconInfo } from './tools/shared.js';
 export declare function registerGetHelpPrompt(server: McpServer, instructions: string, iconInfo?: IconInfo): void;
-export {};

package/dist/prompts.js

@@ -1,20 +1,13 @@
+import { withDefaultIcons } from './tools/shared.js';
+const HELP_PROMPT_NAME = 'get-help';
+const HELP_PROMPT_TITLE = 'Get Help';
+const HELP_PROMPT_DESCRIPTION = 'Return the filesystem-mcp usage instructions.';
 export function registerGetHelpPrompt(server, instructions, iconInfo) {
-    const description = 'Return the filesystem-mcp usage instructions.';
-    server.registerPrompt('get-help', {
-        title: 'Get Help',
-        description,
-        ...(iconInfo
-            ? {
-                icons: [
-                    {
-                        src: iconInfo.src,
-                        mimeType: iconInfo.mimeType,
-                    },
-                ],
-            }
-            : {}),
-    }, () => ({
-        description,
+    server.registerPrompt(HELP_PROMPT_NAME, withDefaultIcons({
+        title: HELP_PROMPT_TITLE,
+        description: HELP_PROMPT_DESCRIPTION,
+    }, iconInfo), () => ({
+        description: HELP_PROMPT_DESCRIPTION,
         messages: [
             {
                 role: 'user',

package/dist/resources.d.ts

@@ -1,9 +1,5 @@
 import type { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
 import type { ResourceStore } from './lib/resource-store.js';
-interface IconInfo {
-    src: string;
-    mimeType: string;
-}
+import { type IconInfo } from './tools/shared.js';
 export declare function registerInstructionResource(server: McpServer, instructions: string, iconInfo?: IconInfo): void;
 export declare function registerResultResources(server: McpServer, store: ResourceStore, iconInfo?: IconInfo): void;
-export {};

package/dist/resources.js

@@ -1,28 +1,24 @@
 import { ResourceTemplate } from '@modelcontextprotocol/sdk/server/mcp.js';
 import { ErrorCode, McpError } from './lib/errors.js';
+import { withDefaultIcons } from './tools/shared.js';
 const RESULT_TEMPLATE = new ResourceTemplate('filesystem-mcp://result/{id}', {
     list: undefined,
 });
+const INSTRUCTIONS_RESOURCE_NAME = 'filesystem-mcp-instructions';
+const INSTRUCTIONS_RESOURCE_URI = 'internal://instructions';
+const INSTRUCTIONS_RESOURCE_DESCRIPTION = 'Guidance for using the filesystem-mcp MCP tools effectively.';
+const RESULT_RESOURCE_NAME = 'filesystem-mcp-result';
+const RESULT_RESOURCE_DESCRIPTION = 'Ephemeral cached tool output exposed as an MCP resource. Not guaranteed to be listed via resources/list.';
 export function registerInstructionResource(server, instructions, iconInfo) {
-    server.registerResource('filesystem-mcp-instructions', 'internal://instructions', {
+    server.registerResource(INSTRUCTIONS_RESOURCE_NAME, INSTRUCTIONS_RESOURCE_URI, withDefaultIcons({
         title: 'Server Instructions',
-        description: 'Guidance for using the filesystem-mcp MCP tools effectively.',
+        description: INSTRUCTIONS_RESOURCE_DESCRIPTION,
         mimeType: 'text/markdown',
         annotations: {
             audience: ['assistant'],
             priority: 0.8,
         },
-        ...(iconInfo
-            ? {
-                icons: [
-                    {
-                        src: iconInfo.src,
-                        mimeType: iconInfo.mimeType,
-                    },
-                ],
-            }
-            : {}),
-    }, (uri) => ({
+    }, iconInfo), (uri) => ({
         contents: [
             {
                 uri: uri.href,
@@ -33,25 +29,15 @@ export function registerInstructionResource(server, instructions, iconInfo) {
     }));
 }
 export function registerResultResources(server, store, iconInfo) {
-    server.registerResource('filesystem-mcp-result', RESULT_TEMPLATE, {
+    server.registerResource(RESULT_RESOURCE_NAME, RESULT_TEMPLATE, withDefaultIcons({
         title: 'Cached Tool Result',
-        description: 'Ephemeral cached tool output exposed as an MCP resource. Not guaranteed to be listed via resources/list.',
+        description: RESULT_RESOURCE_DESCRIPTION,
         mimeType: 'text/plain',
         annotations: {
             audience: ['assistant'],
             priority: 0.3,
         },
-        ...(iconInfo
-            ? {
-                icons: [
-                    {
-                        src: iconInfo.src,
-                        mimeType: iconInfo.mimeType,
-                    },
-                ],
-            }
-            : {}),
-    }, (uri, variables) => {
+    }, iconInfo), (uri, variables) => {
         const { id } = variables;
         if (typeof id !== 'string' || id.length === 0) {
             throw new McpError(ErrorCode.E_INVALID_INPUT, 'Missing resource id');