@j0hanz/fs-context-mcp 2.2.0 → 2.3.0

package/dist/lib/path-validation.js

@@ -4,6 +4,8 @@ import * as path from 'node:path';
 import { fileURLToPath } from 'node:url';
 import { ErrorCode, isNodeError, McpError } from './errors.js';
 import { assertNotAborted, withAbort } from './fs-helpers.js';
+const IS_WINDOWS = process.platform === 'win32';
+const PATH_SEPARATOR = path.sep;
 function expandHome(filepath) {
     if (filepath.startsWith('~/') || filepath === '~') {
         return path.join(os.homedir(), filepath.slice(1));
@@ -13,16 +15,24 @@ function expandHome(filepath) {
 export function normalizePath(p) {
     const expanded = expandHome(p);
     const resolved = path.resolve(expanded);
-    if (process.platform === 'win32' && /^[A-Z]:/.test(resolved)) {
+    if (IS_WINDOWS && /^[A-Z]:/.test(resolved)) {
         return resolved.charAt(0).toLowerCase() + resolved.slice(1);
     }
     return resolved;
 }
+function isEscapingRoot(relative) {
+    if (relative === '')
+        return false;
+    if (relative === '..')
+        return true;
+    const parentPrefix = `..${PATH_SEPARATOR}`;
+    return relative.startsWith(parentPrefix);
+}
 function resolveWithinRoot(root, input) {
     const resolved = path.resolve(root, input);
     const relative = path.relative(root, resolved);
     if (relative === '' ||
-        (!relative.startsWith('..') && !path.isAbsolute(relative))) {
+        (!isEscapingRoot(relative) && !path.isAbsolute(relative))) {
         return resolved;
     }
     return null;
@@ -35,9 +45,8 @@ function rethrowIfAborted(error) {
         throw error;
     }
 }
-const PATH_SEPARATOR = process.platform === 'win32' ? '\\' : '/';
 function normalizeForComparison(value) {
-    return process.platform === 'win32' ? value.toLowerCase() : value;
+    return IS_WINDOWS ? value.toLowerCase() : value;
 }
 function isSamePath(left, right) {
     return normalizeForComparison(left) === normalizeForComparison(right);
@@ -57,51 +66,60 @@ function normalizeAllowedDirectory(dir) {
         return root;
     return stripTrailingSeparator(normalized);
 }
-let allowedDirectories = [];
-function setAllowedDirectories(dirs) {
+function normalizeAllowedDirectories(dirs) {
     const normalized = dirs
         .map(normalizeAllowedDirectory)
         .filter((dir) => dir.length > 0);
-    allowedDirectories = [...new Set(normalized)];
+    return [...new Set(normalized)];
+}
+let allowedDirectoriesExpanded = [];
+let allowedDirectoriesPrimary = [];
+function setAllowedDirectoriesState(primary, expanded) {
+    allowedDirectoriesPrimary = [...new Set(primary)];
+    allowedDirectoriesExpanded = [...new Set(expanded)];
 }
 export function getAllowedDirectories() {
-    return [...allowedDirectories];
+    return [...allowedDirectoriesExpanded];
+}
+function getAllowedDirectoriesForRelativeResolution() {
+    return allowedDirectoriesPrimary.length > 0
+        ? [...allowedDirectoriesPrimary]
+        : [...allowedDirectoriesExpanded];
 }
 export function isPathWithinDirectories(normalizedPath, allowedDirs) {
     const candidate = normalizeForComparison(normalizedPath);
     return allowedDirs.some((allowedDir) => isPathWithinRoot(normalizeForComparison(allowedDir), candidate));
 }
-async function expandAllowedDirectories(dirs, signal) {
-    const normalizedDirs = dirs
-        .map(normalizeAllowedDirectory)
-        .filter((dir) => Boolean(dir) && dir.length > 0);
-    const realPaths = await Promise.all(normalizedDirs.map((dir) => resolveRealPath(dir, signal)));
-    const expanded = [];
-    for (let i = 0; i < normalizedDirs.length; i++) {
-        const normalized = normalizedDirs[i];
-        if (!normalized)
-            continue;
-        expanded.push(normalized);
-        const normalizedReal = realPaths[i];
-        if (normalizedReal && !isSamePath(normalizedReal, normalized)) {
-            expanded.push(normalizedReal);
-        }
-    }
-    return [...new Set(expanded)];
-}
 async function resolveRealPath(normalized, signal) {
     try {
         assertNotAborted(signal);
         const realPath = await withAbort(fs.realpath(normalized), signal);
         return normalizeAllowedDirectory(realPath);
     }
-    catch {
+    catch (error) {
+        rethrowIfAborted(error);
         return null;
     }
 }
+async function expandAllowedDirectories(primaryDirs, signal) {
+    const realPaths = await Promise.all(primaryDirs.map((dir) => resolveRealPath(dir, signal)));
+    const expanded = [];
+    for (let i = 0; i < primaryDirs.length; i++) {
+        const primary = primaryDirs[i];
+        if (!primary)
+            continue;
+        expanded.push(primary);
+        const real = realPaths[i];
+        if (real && !isSamePath(real, primary)) {
+            expanded.push(real);
+        }
+    }
+    return [...new Set(expanded)];
+}
 export async function setAllowedDirectoriesResolved(dirs, signal) {
-    const expanded = await expandAllowedDirectories(dirs, signal);
-    setAllowedDirectories(expanded);
+    const primary = normalizeAllowedDirectories(dirs);
+    const expanded = await expandAllowedDirectories(primary, signal);
+    setAllowedDirectoriesState(primary, expanded);
 }
 export const RESERVED_DEVICE_NAMES = new Set([
     'CON',
@@ -158,7 +176,7 @@ function getReservedDeviceName(segment) {
     return RESERVED_DEVICE_NAMES.has(baseName) ? baseName : undefined;
 }
 export function getReservedDeviceNameForPath(requestedPath) {
-    if (process.platform !== 'win32')
+    if (!IS_WINDOWS)
         return undefined;
     const segments = requestedPath.split(/[\\/]/);
     for (const segment of segments) {
@@ -169,7 +187,7 @@ export function getReservedDeviceNameForPath(requestedPath) {
     return undefined;
 }
 function ensureNoReservedWindowsNames(requestedPath) {
-    if (process.platform !== 'win32')
+    if (!IS_WINDOWS)
         return;
     const segments = requestedPath.split(/[\\/]/);
     for (const segment of segments) {
@@ -180,7 +198,7 @@ function ensureNoReservedWindowsNames(requestedPath) {
     }
 }
 export function isWindowsDriveRelativePath(requestedPath) {
-    if (process.platform !== 'win32')
+    if (!IS_WINDOWS)
         return false;
     const driveLetter = requestedPath.charCodeAt(0);
     const isAsciiLetter = (driveLetter >= 65 && driveLetter <= 90) ||
@@ -198,11 +216,11 @@ function ensureNoWindowsDriveRelativePath(requestedPath) {
 function resolveRequestedPath(requestedPath) {
     const expanded = expandHome(requestedPath);
     if (!path.isAbsolute(expanded)) {
-        const allowedDirs = getAllowedDirectories();
-        if (allowedDirs.length > 1) {
+        const roots = getAllowedDirectoriesForRelativeResolution();
+        if (roots.length > 1) {
             throw new McpError(ErrorCode.E_INVALID_INPUT, 'Relative paths are ambiguous when multiple roots are configured. Provide an absolute path or specify the full root path.', requestedPath);
         }
-        const baseDir = allowedDirs[0];
+        const baseDir = roots[0];
         if (baseDir) {
             return normalizePath(path.resolve(baseDir, expanded));
         }
@@ -252,8 +270,7 @@ function toMcpError(requestedPath, error) {
     }
     let message = '';
     if (error instanceof Error) {
-        const { message: errorMessage } = error;
-        message = errorMessage;
+        ({ message } = error);
     }
     else if (typeof error === 'string') {
         message = error;
@@ -368,4 +385,3 @@ export async function getValidRootDirectories(roots, signal) {
     }
     return validDirs;
 }
-//# sourceMappingURL=path-validation.js.map

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

@@ -20,4 +20,3 @@ interface ResourceStoreOptions {
 }
 export declare function createInMemoryResourceStore(options?: Partial<ResourceStoreOptions>): ResourceStore;
 export {};
-//# sourceMappingURL=resource-store.d.ts.map

package/dist/lib/resource-store.js

@@ -72,4 +72,3 @@ export function createInMemoryResourceStore(options = {}) {
     }
     return { putText, getText, clear };
 }
-//# sourceMappingURL=resource-store.js.map

package/dist/resources.d.ts

@@ -1,5 +1,4 @@
 import type { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
 import type { ResourceStore } from './lib/resource-store.js';
-export declare function registerInstructionResource(server: McpServer, instructions: string): void;
-export declare function registerResultResources(server: McpServer, store: ResourceStore): void;
-//# sourceMappingURL=resources.d.ts.map
+export declare function registerInstructionResource(server: McpServer, instructions: string, serverIcon?: string): void;
+export declare function registerResultResources(server: McpServer, store: ResourceStore, serverIcon?: string): void;

package/dist/resources.js

@@ -3,11 +3,18 @@ import { ErrorCode, McpError } from './lib/errors.js';
 const RESULT_TEMPLATE = new ResourceTemplate('fs-context://result/{id}', {
     list: undefined,
 });
-export function registerInstructionResource(server, instructions) {
+export function registerInstructionResource(server, instructions, serverIcon) {
     server.registerResource('fs-context-instructions', 'internal://instructions', {
         title: 'Server Instructions',
         description: 'Guidance for using the fs-context MCP tools effectively.',
         mimeType: 'text/markdown',
+        ...(serverIcon
+            ? {
+                icons: [
+                    { src: serverIcon, mimeType: 'image/svg+xml', sizes: ['any'] },
+                ],
+            }
+            : {}),
     }, (uri) => ({
         contents: [
             {
@@ -18,11 +25,18 @@ export function registerInstructionResource(server, instructions) {
         ],
     }));
 }
-export function registerResultResources(server, store) {
+export function registerResultResources(server, store, serverIcon) {
     server.registerResource('fs-context-result', RESULT_TEMPLATE, {
         title: 'Cached Tool Result',
         description: 'Ephemeral cached tool output exposed as an MCP resource. Not guaranteed to be listed via resources/list.',
         mimeType: 'text/plain',
+        ...(serverIcon
+            ? {
+                icons: [
+                    { src: serverIcon, mimeType: 'image/svg+xml', sizes: ['any'] },
+                ],
+            }
+            : {}),
     }, (uri, variables) => {
         const { id } = variables;
         if (typeof id !== 'string' || id.length === 0) {
@@ -40,4 +54,3 @@ export function registerResultResources(server, store) {
         };
     });
 }
-//# sourceMappingURL=resources.js.map

package/dist/schemas.d.ts

@@ -259,4 +259,3 @@ export declare const GetMultipleFileInfoOutputSchema: z.ZodObject<{
     }, z.core.$strip>>;
 }, z.core.$strip>;
 export {};
-//# sourceMappingURL=schemas.d.ts.map

package/dist/schemas.js

@@ -2,6 +2,8 @@ import { z } from 'zod';
 function isSafeGlobPattern(value) {
     if (value.length === 0)
         return false;
+    if (value.includes('**/**/**'))
+        return false;
     const absolutePattern = /^([/\\]|[A-Za-z]:[/\\]|\\\\)/u;
     if (absolutePattern.test(value)) {
         return false;
@@ -12,14 +14,15 @@ function isSafeGlobPattern(value) {
     return true;
 }
 const MAX_PATH_LENGTH = 4096;
-const OptionalPathSchema = z
-    .string()
-    .max(MAX_PATH_LENGTH, `Path is too long (max ${MAX_PATH_LENGTH} characters)`)
-    .optional();
-const RequiredPathSchema = z
+const DESC_PATH_ROOT = 'Base directory for the operation (leave empty for workspace root). ' +
+    'If multiple roots are configured, path is required and must be absolute. ' +
+    'Examples: "src", "src/components"';
+const DESC_PATH_REQUIRED = 'Absolute path to file or directory. Examples: "src/index.ts", "README.md"';
+const PathSchemaBase = z
     .string()
-    .min(1, 'Path cannot be empty')
-    .max(MAX_PATH_LENGTH, `Path is too long (max ${MAX_PATH_LENGTH} characters)`);
+    .max(MAX_PATH_LENGTH, `Path exceeds maximum length of ${MAX_PATH_LENGTH} characters`);
+const OptionalPathSchema = PathSchemaBase.optional();
+const RequiredPathSchema = PathSchemaBase.min(1, 'Path is required');
 const FileTypeSchema = z.enum(['file', 'directory', 'symlink', 'other']);
 const TreeEntryTypeSchema = z.enum(['file', 'directory', 'symlink', 'other']);
 const TreeEntrySchema = z.lazy(() => z.object({
@@ -100,14 +103,12 @@ const ReadRangeInputSchema = z.strictObject({
     endLine: LineNumberSchema.optional(),
 });
 export const ListDirectoryInputSchema = z.strictObject({
-    path: OptionalPathSchema.describe('Directory path to list (leave empty for workspace root). ' +
-        'If multiple roots are configured, path is required and must be absolute. ' +
-        'Examples: "src", "src/components", "lib/utils"'),
+    path: OptionalPathSchema.describe(DESC_PATH_ROOT),
     includeHidden: z
         .boolean()
         .optional()
         .default(false)
-        .describe('Include hidden files and directories'),
+        .describe('Include hidden files and directories (starting with .)'),
     includeIgnored: z
         .boolean()
         .optional()
@@ -118,27 +119,15 @@ export const ListAllowedDirectoriesInputSchema = z
     .strictObject({})
     .describe('No input parameters.');
 export const SearchFilesInputSchema = z.strictObject({
-    path: OptionalPathSchema.describe('Base directory to search from (leave empty for workspace root). ' +
-        'If multiple roots are configured, path is required and must be absolute. ' +
-        'Examples: "src", "lib", "tests"'),
+    path: OptionalPathSchema.describe(DESC_PATH_ROOT),
     pattern: z
         .string()
-        .min(1, 'Pattern cannot be empty')
-        .max(1000, 'Pattern is too long (max 1000 characters)')
-        .refine((val) => {
-        try {
-            if (val.includes('**/**/**')) {
-                return false;
-            }
-            return isSafeGlobPattern(val);
-        }
-        catch {
-            return false;
-        }
-    }, {
+        .min(1, 'Pattern is required')
+        .max(1000, 'Pattern exceeds 1000 characters')
+        .refine((val) => isSafeGlobPattern(val), {
         error: 'Invalid glob pattern syntax or unsafe path (absolute/.. segments not allowed)',
     })
-        .describe('Glob pattern to match files. Examples: "**/*.ts" (all TypeScript files), "src/**/*.js" (JS files in src), "*.json" (JSON files in current dir)'),
+        .describe('Glob pattern to match files. Examples: "**/*.ts", "src/**/*.js", "*.json"'),
     maxResults: z
         .number()
         .int({ error: 'maxResults must be an integer' })
@@ -155,9 +144,7 @@ export const SearchFilesInputSchema = z.strictObject({
         'Set to true when debugging in dependencies.'),
 });
 export const TreeInputSchema = z.strictObject({
-    path: OptionalPathSchema.describe('Base directory to render as a tree (leave empty for workspace root). ' +
-        'If multiple roots are configured, path is required and must be absolute. ' +
-        'Examples: "src", "lib"'),
+    path: OptionalPathSchema.describe(DESC_PATH_ROOT),
     maxDepth: z
         .number()
         .int({ error: 'maxDepth must be an integer' })
@@ -178,7 +165,7 @@ export const TreeInputSchema = z.strictObject({
         .boolean()
         .optional()
         .default(false)
-        .describe('Include hidden files and directories'),
+        .describe('Include hidden files and directories (starting with .)'),
     includeIgnored: z
         .boolean()
         .optional()
@@ -187,49 +174,47 @@ export const TreeInputSchema = z.strictObject({
         'When true, also disables root .gitignore filtering.'),
 });
 export const SearchContentInputSchema = z.strictObject({
-    path: OptionalPathSchema.describe('Base directory or file path to search within (leave empty for workspace root). ' +
-        'If multiple roots are configured, path is required and must be absolute. ' +
-        'Examples: "src", "lib", "tests", "src/index.ts"'),
+    path: OptionalPathSchema.describe(DESC_PATH_ROOT),
     pattern: z
         .string()
-        .min(1, 'Pattern cannot be empty')
-        .max(1000, 'Pattern is too long (max 1000 characters)')
-        .describe('Text to search for. Examples: "console.log", "import React", "className"'),
+        .min(1, 'Pattern is required')
+        .max(1000, 'Pattern exceeds 1000 characters')
+        .describe('Text to search for (regex). Examples: "console\\.log", "class User"'),
     includeHidden: z
         .boolean()
         .optional()
         .default(false)
-        .describe('Include hidden files and directories'),
+        .describe('Include hidden files and directories (starting with .)'),
 });
 export const ReadFileInputSchema = ReadRangeInputSchema.extend({
-    path: RequiredPathSchema.describe('Path to the file to read. ' +
-        'Examples: "README.md", "src/index.ts", "package.json"'),
+    path: RequiredPathSchema.describe(DESC_PATH_REQUIRED),
     head: HeadLinesSchema.describe('Read only the first N lines of the file (useful for previewing large files)'),
-    startLine: LineNumberSchema.optional().describe('1-based line number to start reading from (inclusive). Useful for reading context around a match.'),
+    startLine: LineNumberSchema.optional().describe('1-based line number to start reading from (inclusive).'),
     endLine: LineNumberSchema.optional().describe('1-based line number to stop reading at (inclusive). Requires startLine.'),
-}).superRefine(validateReadRange);
+})
+    .strict()
+    .superRefine(validateReadRange);
 export const ReadMultipleFilesInputSchema = ReadRangeInputSchema.extend({
     paths: z
         .array(RequiredPathSchema)
         .min(1, 'At least one path is required')
         .max(100, 'Cannot read more than 100 files at once')
-        .describe('Array of file paths to read. ' +
-        'Examples: ["README.md", "package.json"], ["src/index.ts", "src/server.ts"]'),
+        .describe('Array of file paths to read. Examples: ["README.md", "src/index.ts"]'),
     head: HeadLinesSchema.describe('Read only the first N lines of each file'),
     startLine: LineNumberSchema.optional().describe('1-based line number to start reading from (inclusive), applied to each file.'),
     endLine: LineNumberSchema.optional().describe('1-based line number to stop reading at (inclusive), applied to each file. Requires startLine.'),
-}).superRefine(validateReadRange);
+})
+    .strict()
+    .superRefine(validateReadRange);
 export const GetFileInfoInputSchema = z.strictObject({
-    path: RequiredPathSchema.describe('Path to file or directory. ' +
-        'Examples: "src", "README.md", "src/index.ts"'),
+    path: RequiredPathSchema.describe(DESC_PATH_REQUIRED),
 });
 export const GetMultipleFileInfoInputSchema = z.strictObject({
     paths: z
         .array(RequiredPathSchema)
         .min(1, 'At least one path is required')
         .max(100, 'Cannot get info for more than 100 files at once')
-        .describe('Array of file or directory paths. ' +
-        'Examples: ["src", "lib"], ["package.json", "tsconfig.json"]'),
+        .describe('Array of file or directory paths. Examples: ["src", "lib"]'),
 });
 export const ListAllowedDirectoriesOutputSchema = z.object({
     ok: z.boolean(),
@@ -333,4 +318,3 @@ export const GetMultipleFileInfoOutputSchema = z.object({
     summary: OperationSummarySchema.optional(),
     error: ErrorSchema.optional(),
 });
-//# sourceMappingURL=schemas.js.map

package/dist/server.d.ts

@@ -11,4 +11,3 @@ interface ServerOptions {
 export declare function createServer(options?: ServerOptions): McpServer;
 export declare function startServer(server: McpServer): Promise<void>;
 export {};
-//# sourceMappingURL=server.d.ts.map

package/dist/server.js

@@ -1,5 +1,6 @@
 import * as fs from 'node:fs/promises';
 import * as path from 'node:path';
+import { readFileSync } from 'node:fs';
 import { fileURLToPath } from 'node:url';
 import { parseArgs as parseNodeArgs } from 'node:util';
 import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
@@ -41,7 +42,7 @@ async function validateDirectoryPath(inputPath) {
 function assertDirectory(stats, inputPath) {
     if (stats.isDirectory())
         return;
-    throw new Error(`Error: '${inputPath}' is not a directory`);
+    throw new Error(`Error: ${inputPath} is not a directory`);
 }
 function isCliError(error) {
     return error instanceof Error && error.message.startsWith('Error:');
@@ -49,7 +50,7 @@ function isCliError(error) {
 function normalizeDirectoryError(error, inputPath) {
     if (isCliError(error))
         return error;
-    return new Error(`Error: Cannot access directory '${inputPath}'`);
+    return new Error(`Error: Cannot access directory ${inputPath}`);
 }
 async function normalizeCliDirectories(args) {
     return Promise.all(args.map(validateDirectoryPath));
@@ -79,8 +80,11 @@ export async function parseArgs() {
 const ROOTS_TIMEOUT_MS = 5000;
 const ROOTS_DEBOUNCE_MS = 100;
 const MCP_LOGGER_NAME = 'fs-context';
+function canSendMcpLogs(server) {
+    return Boolean(server.server.getClientCapabilities());
+}
 function logToMcp(server, level, data) {
-    if (!server) {
+    if (!server || !canSendMcpLogs(server)) {
         console.error(data);
         return;
     }
@@ -90,7 +94,7 @@ function logToMcp(server, level, data) {
         data,
     };
     void server.sendLoggingMessage(params).catch((error) => {
-        console.error(`Failed to send MCP log (${level}):`, data, error instanceof Error ? error.message : String(error));
+        console.error(`Failed to send MCP log: ${level} │ ${data}`, data, error instanceof Error ? error.message : String(error));
     });
 }
 class RootsManager {
@@ -143,10 +147,10 @@ class RootsManager {
     }
     logMissingDirectories(server) {
         if (this.options.allowCwd) {
-            logToMcp(server, 'notice', 'No directories specified. Using current working directory.');
+            logToMcp(server, 'notice', 'No allowed directories specified. Using the current working directory as an allowed directory.');
             return;
         }
-        logToMcp(server, 'warning', 'No directories configured. Use --allow-cwd flag or specify directories via CLI/roots protocol. The server will not be able to access any files until directories are configured.');
+        logToMcp(server, 'warning', 'No allowed directories specified. Please provide directories as command-line arguments or enable --allow-cwd to use the current working directory.');
     }
     async updateRootsFromClient(server) {
         try {
@@ -177,15 +181,21 @@ function getRootsManager(server) {
     }
     return manager;
 }
+const RootSchema = z
+    .object({
+    uri: z.string(),
+    name: z.string().optional(),
+})
+    .strict();
 const RootsResponseSchema = z.object({
-    roots: z.array(z.any()).optional(),
+    roots: z.array(RootSchema).optional(),
 });
 function extractRoots(value) {
     const parsed = RootsResponseSchema.safeParse(value);
     if (!parsed.success || !parsed.data.roots) {
         return [];
     }
-    return parsed.data.roots.filter(isRoot);
+    return parsed.data.roots.filter(isRoot).map(normalizeRoot);
 }
 async function resolveRootDirectories(roots) {
     if (roots.length === 0)
@@ -204,6 +214,9 @@ function isRoot(value) {
         'uri' in value &&
         typeof value.uri === 'string');
 }
+function normalizeRoot(root) {
+    return root.name ? { uri: root.uri, name: root.name } : { uri: root.uri };
+}
 async function filterRootsWithinBaseline(roots, baseline, signal) {
     const normalizedBaseline = normalizeAllowedDirectories(baseline);
     const filtered = [];
@@ -242,6 +255,16 @@ try {
 catch (error) {
     console.error('[WARNING] Failed to load instructions.md:', error instanceof Error ? error.message : String(error));
 }
+function getLocalIconData() {
+    try {
+        const iconPath = new URL('../assets/logo.svg', import.meta.url);
+        const buffer = readFileSync(iconPath);
+        return `data:image/svg+xml;base64,${buffer.toString('base64')}`;
+    }
+    catch {
+        return undefined;
+    }
+}
 function resolveToolErrorCode(message) {
     const explicit = extractExplicitErrorCode(message);
     if (explicit)
@@ -288,6 +311,7 @@ function patchToolErrorHandling(server) {
 }
 export function createServer(options = {}) {
     const resourceStore = createInMemoryResourceStore();
+    const localIcon = getLocalIconData();
     const serverConfig = {
         capabilities: {
             logging: {},
@@ -301,15 +325,23 @@ export function createServer(options = {}) {
     const server = new McpServer({
         name: 'fs-context-mcp',
         version: SERVER_VERSION,
+        ...(localIcon
+            ? {
+                icons: [
+                    { src: localIcon, mimeType: 'image/svg+xml', sizes: ['any'] },
+                ],
+            }
+            : {}),
     }, serverConfig);
     patchToolErrorHandling(server);
     const rootsManager = new RootsManager(options);
     rootsManagers.set(server, rootsManager);
-    registerInstructionResource(server, serverInstructions);
-    registerResultResources(server, resourceStore);
+    registerInstructionResource(server, serverInstructions, localIcon);
+    registerResultResources(server, resourceStore, localIcon);
     registerAllTools(server, {
         resourceStore,
         isInitialized: () => rootsManager.isInitialized(),
+        ...(localIcon ? { serverIcon: localIcon } : {}),
     });
     return server;
 }
@@ -321,4 +353,3 @@ export async function startServer(server) {
     await server.connect(transport);
     rootsManager.logMissingDirectoriesIfNeeded(server);
 }
-//# sourceMappingURL=server.js.map

package/dist/tools/list-directory.d.ts

@@ -1,4 +1,3 @@
 import type { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
 import { type ToolRegistrationOptions } from './shared.js';
 export declare function registerListDirectoryTool(server: McpServer, options?: ToolRegistrationOptions): void;
-//# sourceMappingURL=list-directory.d.ts.map

package/dist/tools/list-directory.js

@@ -80,6 +80,18 @@ async function handleListDirectory(args, signal) {
 }
 export function registerListDirectoryTool(server, options = {}) {
     const handler = (args, extra) => withToolDiagnostics('ls', () => withToolErrorHandling(() => handleListDirectory(args, extra.signal), (error) => buildToolErrorResponse(error, ErrorCode.E_NOT_DIRECTORY, args.path ?? '.')), { path: args.path ?? '.' });
-    server.registerTool('ls', LIST_DIRECTORY_TOOL, wrapToolHandler(handler, { guard: options.isInitialized }));
+    server.registerTool('ls', {
+        ...LIST_DIRECTORY_TOOL,
+        ...(options.serverIcon
+            ? {
+                icons: [
+                    {
+                        src: options.serverIcon,
+                        mimeType: 'image/svg+xml',
+                        sizes: ['any'],
+                    },
+                ],
+            }
+            : {}),
+    }, wrapToolHandler(handler, { guard: options.isInitialized }));
 }
-//# sourceMappingURL=list-directory.js.map

package/dist/tools/read-multiple.d.ts

@@ -1,4 +1,3 @@
 import type { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
 import { type ToolRegistrationOptions } from './shared.js';
 export declare function registerReadMultipleFilesTool(server: McpServer, options?: ToolRegistrationOptions): void;
-//# sourceMappingURL=read-multiple.d.ts.map

package/dist/tools/read-multiple.js

@@ -104,6 +104,18 @@ export function registerReadMultipleFilesTool(server, options = {}) {
             }
         }, (error) => buildToolErrorResponse(error, ErrorCode.E_NOT_FILE, primaryPath)), { path: primaryPath });
     };
-    server.registerTool('read_many', READ_MULTIPLE_FILES_TOOL, wrapToolHandler(handler, { guard: options.isInitialized }));
+    server.registerTool('read_many', {
+        ...READ_MULTIPLE_FILES_TOOL,
+        ...(options.serverIcon
+            ? {
+                icons: [
+                    {
+                        src: options.serverIcon,
+                        mimeType: 'image/svg+xml',
+                        sizes: ['any'],
+                    },
+                ],
+            }
+            : {}),
+    }, wrapToolHandler(handler, { guard: options.isInitialized }));
 }
-//# sourceMappingURL=read-multiple.js.map

package/dist/tools/read.d.ts

@@ -1,4 +1,3 @@
 import type { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
 import { type ToolRegistrationOptions } from './shared.js';
 export declare function registerReadFileTool(server: McpServer, options?: ToolRegistrationOptions): void;
-//# sourceMappingURL=read.d.ts.map