@j0hanz/filesystem-mcp 1.2.2 → 1.2.3

package/dist/schemas.js

@@ -1,5 +1,5 @@
 import { z } from 'zod';
-import { ErrorCode } from './config.js';
+import { ErrorCode } from './lib/errors.js';
 function isSafeGlobPattern(value) {
     if (value.length === 0)
         return false;
@@ -90,7 +90,7 @@ const FileInfoSchema = z.strictObject({
     mimeType: z.string().optional().describe('MIME type'),
     symlinkTarget: z.string().optional().describe('Target (symlink)'),
 });
-const OperationSummarySchema = z.object({
+const OperationSummarySchema = z.strictObject({
     total: z.number().describe('Total'),
     succeeded: z.number().describe('Succeeded'),
     failed: z.number().describe('Failed'),
@@ -293,7 +293,7 @@ export const GetMultipleFileInfoInputSchema = z.strictObject({
         .max(100, 'Max 100 files')
         .describe('File/directory paths. e.g. ["src", "lib"]'),
 });
-export const ListAllowedDirectoriesOutputSchema = z.object({
+export const ListAllowedDirectoriesOutputSchema = z.strictObject({
     ok: z.boolean(),
     directories: z.array(z.string()).optional().describe('Allowed directories'),
     rootsCount: z.number().optional().describe('Number of roots'),
@@ -303,11 +303,11 @@ export const ListAllowedDirectoriesOutputSchema = z.object({
         .describe('Multiple roots configured'),
     error: ErrorSchema.optional(),
 });
-export const ListDirectoryOutputSchema = z.object({
+export const ListDirectoryOutputSchema = z.strictObject({
     ok: z.boolean(),
     path: z.string().optional(),
     entries: z
-        .array(z.object({
+        .array(z.strictObject({
         name: z.string().describe('Entry name'),
         relativePath: z.string().optional(),
         type: FileTypeSchema,
@@ -327,7 +327,7 @@ export const ListDirectoryOutputSchema = z.object({
     symlinksNotFollowed: z.number().optional(),
     error: ErrorSchema.optional(),
 });
-const SearchSummarySchema = z.object({
+const SearchSummarySchema = z.strictObject({
     totalMatches: z.number().optional().describe('Total matches found'),
     truncated: z.boolean().optional().describe('Results truncated?'),
     resourceUri: z.string().optional().describe('Full results URI'),
@@ -338,7 +338,7 @@ export const SearchFilesOutputSchema = SearchSummarySchema.extend({
     root: z.string().optional().describe('Search root'),
     pattern: z.string().optional().describe('Glob pattern used'),
     results: z
-        .array(z.object({
+        .array(z.strictObject({
         path: z.string().describe('Relative path'),
         size: z.number().optional(),
         modified: z.string().optional(),
@@ -356,7 +356,7 @@ export const SearchContentOutputSchema = SearchSummarySchema.extend({
         .describe('Pattern interpretation'),
     caseSensitive: z.boolean().optional().describe('Case-sensitive matching'),
     matches: z
-        .array(z.object({
+        .array(z.strictObject({
         file: z.string().describe('Relative path'),
         line: z.number(),
         content: z.string(),
@@ -379,7 +379,7 @@ export const SearchContentOutputSchema = SearchSummarySchema.extend({
         .describe('Lines skipped due to regex timeout'),
     stoppedReason: SearchStopReasonSchema.optional().describe('Why search stopped'),
 });
-export const TreeOutputSchema = z.object({
+export const TreeOutputSchema = z.strictObject({
     ok: z.boolean(),
     root: z.string().optional(),
     tree: TreeEntrySchema.optional(),
@@ -388,7 +388,7 @@ export const TreeOutputSchema = z.object({
     totalEntries: z.number().optional(),
     error: ErrorSchema.optional(),
 });
-const ReadResultSchema = z.object({
+const ReadResultSchema = z.strictObject({
     content: z.string().optional().describe('Content'),
     truncated: z.boolean().optional().describe('Truncated?'),
     resourceUri: z.string().optional().describe('Full content URI'),
@@ -414,21 +414,21 @@ const ReadMultipleFileResultSchema = ReadResultSchema.extend({
     maxTotalSize: z.number().optional().describe('Max total size budget'),
     error: z.string().optional().describe('Error message'),
 });
-export const ReadMultipleFilesOutputSchema = z.object({
+export const ReadMultipleFilesOutputSchema = z.strictObject({
     ok: z.boolean(),
     results: z.array(ReadMultipleFileResultSchema).optional(),
     summary: OperationSummarySchema.optional(),
     error: ErrorSchema.optional(),
 });
-export const GetFileInfoOutputSchema = z.object({
+export const GetFileInfoOutputSchema = z.strictObject({
     ok: z.boolean(),
     info: FileInfoSchema.optional(),
     error: ErrorSchema.optional(),
 });
-export const GetMultipleFileInfoOutputSchema = z.object({
+export const GetMultipleFileInfoOutputSchema = z.strictObject({
     ok: z.boolean(),
     results: z
-        .array(z.object({
+        .array(z.strictObject({
         path: z.string(),
         info: FileInfoSchema.optional(),
         error: z.string().optional(),
@@ -440,7 +440,7 @@ export const GetMultipleFileInfoOutputSchema = z.object({
 export const CreateDirectoryInputSchema = z.strictObject({
     path: RequiredPathSchema.describe(DESC_PATH_REQUIRED),
 });
-export const CreateDirectoryOutputSchema = z.object({
+export const CreateDirectoryOutputSchema = z.strictObject({
     ok: z.boolean(),
     path: z.string().optional(),
     error: ErrorSchema.optional(),
@@ -449,7 +449,7 @@ export const WriteFileInputSchema = z.strictObject({
     path: RequiredPathSchema.describe(DESC_PATH_REQUIRED),
     content: z.string().describe('Content to write'),
 });
-export const WriteFileOutputSchema = z.object({
+export const WriteFileOutputSchema = z.strictObject({
     ok: z.boolean(),
     path: z.string().optional(),
     bytesWritten: z.number().optional(),
@@ -458,7 +458,7 @@ export const WriteFileOutputSchema = z.object({
 export const EditFileInputSchema = z.strictObject({
     path: RequiredPathSchema.describe(DESC_PATH_REQUIRED),
     edits: z
-        .array(z.object({
+        .array(z.strictObject({
         oldText: z
             .string()
             .describe('Exact literal string to replace — must match character-for-character including whitespace and indentation. Include 3–5 lines of surrounding context to uniquely identify the location.'),
@@ -474,7 +474,7 @@ export const EditFileInputSchema = z.strictObject({
         .default(false)
         .describe('Preview edits without writing. Check unmatchedEdits in the response to verify all oldText values were found.'),
 });
-export const EditFileOutputSchema = z.object({
+export const EditFileOutputSchema = z.strictObject({
     ok: z.boolean(),
     path: z.string().optional(),
     appliedEdits: z.number().optional(),
@@ -492,7 +492,7 @@ export const MoveFileInputSchema = z.strictObject({
     source: RequiredPathSchema.describe('Path to move'),
     destination: RequiredPathSchema.describe('New path'),
 });
-export const MoveFileOutputSchema = z.object({
+export const MoveFileOutputSchema = z.strictObject({
     ok: z.boolean(),
     source: z.string().optional(),
     destination: z.string().optional(),
@@ -511,7 +511,7 @@ export const DeleteFileInputSchema = z.strictObject({
         .default(false)
         .describe('No error if missing'),
 });
-export const DeleteFileOutputSchema = z.object({
+export const DeleteFileOutputSchema = z.strictObject({
     ok: z.boolean(),
     path: z.string().optional(),
     error: ErrorSchema.optional(),
@@ -519,7 +519,7 @@ export const DeleteFileOutputSchema = z.object({
 export const CalculateHashInputSchema = z.strictObject({
     path: RequiredPathSchema.describe(DESC_PATH_REQUIRED),
 });
-export const CalculateHashOutputSchema = z.object({
+export const CalculateHashOutputSchema = z.strictObject({
     ok: z.boolean(),
     path: z.string().optional(),
     hash: z.string().optional().describe('SHA-256 hash'),
@@ -551,7 +551,7 @@ export const DiffFilesInputSchema = z.strictObject({
         .default(false)
         .describe('Strip trailing carriage returns before diffing'),
 });
-export const DiffFilesOutputSchema = z.object({
+export const DiffFilesOutputSchema = z.strictObject({
     ok: z.boolean(),
     diff: z.string().optional().describe('Unified diff content'),
     isIdentical: z.boolean().optional().describe('True if files are identical'),
@@ -582,7 +582,7 @@ export const ApplyPatchInputSchema = z.strictObject({
         .default(false)
         .describe('Validate the patch can be applied without writing. Check `applied` in the response before committing.'),
 });
-export const ApplyPatchOutputSchema = z.object({
+export const ApplyPatchOutputSchema = z.strictObject({
     ok: z.boolean(),
     path: z.string().optional(),
     applied: z.boolean().optional(),
@@ -614,21 +614,21 @@ export const SearchAndReplaceInputSchema = z.strictObject({
         .default(false)
         .describe('Preview matches without writing. Check changedFiles and matches in the response before committing.'),
 });
-export const SearchAndReplaceOutputSchema = z.object({
+export const SearchAndReplaceOutputSchema = z.strictObject({
     ok: z.boolean(),
     matches: z.number().optional().describe('Total matches found'),
     filesChanged: z.number().optional().describe('Files modified'),
     processedFiles: z.number().optional().describe('Files processed'),
     failedFiles: z.number().optional().describe('Files skipped due to errors'),
     failures: z
-        .array(z.object({
+        .array(z.strictObject({
         path: z.string().describe('File path'),
         error: z.string().describe('Error message'),
     }))
         .optional()
         .describe('Sample of per-file errors'),
     changedFiles: z
-        .array(z.object({
+        .array(z.strictObject({
         path: z.string().describe('File path'),
         matches: z.number().describe('Matches in file'),
     }))

package/dist/server/bootstrap.d.ts

@@ -0,0 +1,4 @@
+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>;

package/dist/server/bootstrap.js

@@ -0,0 +1,117 @@
+import * as fs from 'node:fs/promises';
+import * as path from 'node:path';
+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 { 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);
+}

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, startServer } from './server/bootstrap.js';
+export type { ServerOptions } from './server/types.js';