@theia/filesystem 1.45.0 → 1.46.0-next.106

package/src/browser-only/browserfs-filesystem-initialization.ts

@@ -0,0 +1,61 @@
+// *****************************************************************************
+// Copyright (C) 2023 EclipseSource and others.
+//
+// This program and the accompanying materials are made available under the
+// terms of the Eclipse Public License v. 2.0 which is available at
+// http://www.eclipse.org/legal/epl-2.0.
+//
+// This Source Code may also be made available under the following Secondary
+// Licenses when the conditions for such availability set forth in the Eclipse
+// Public License v. 2.0 are satisfied: GNU General Public License, version 2
+// with the GNU Classpath Exception which is available at
+// https://www.gnu.org/software/classpath/license.html.
+//
+// SPDX-License-Identifier: EPL-2.0 OR GPL-2.0-only WITH Classpath-exception-2.0
+// *****************************************************************************
+
+import type { FSModule } from 'browserfs/dist/node/core/FS';
+import type { BrowserFSFileSystemProvider } from './browserfs-filesystem-provider';
+import { injectable } from '@theia/core/shared/inversify';
+import { FileSystem, initialize } from 'browserfs';
+import MountableFileSystem from 'browserfs/dist/node/backend/MountableFileSystem';
+
+export const BrowserFSInitialization = Symbol('BrowserFSInitialization');
+export interface BrowserFSInitialization {
+    createMountableFileSystem(): Promise<MountableFileSystem>
+    initializeFS: (fs: FSModule, provider: BrowserFSFileSystemProvider) => Promise<void>;
+}
+
+@injectable()
+export class DefaultBrowserFSInitialization implements BrowserFSInitialization {
+
+    createMountableFileSystem(): Promise<MountableFileSystem> {
+        return new Promise(resolve => {
+            FileSystem.IndexedDB.Create({}, (e, persistedFS) => {
+                if (e) {
+                    throw e;
+                }
+                if (!persistedFS) {
+                    throw Error('Could not create filesystem');
+                }
+                FileSystem.MountableFileSystem.Create({
+                    '/home': persistedFS
+
+                }, (error, mountableFS) => {
+                    if (error) {
+                        throw error;
+                    }
+                    if (!mountableFS) {
+                        throw Error('Could not create filesystem');
+                    }
+                    initialize(mountableFS);
+                    resolve(mountableFS);
+                });
+            });
+        });
+    }
+
+    async initializeFS(fs: FSModule, provider: BrowserFSFileSystemProvider): Promise<void> {
+
+    }
+}

package/src/browser-only/browserfs-filesystem-provider.ts

@@ -0,0 +1,462 @@
+// *****************************************************************************
+// Copyright (C) 2023 EclipseSource and others.
+//
+// This program and the accompanying materials are made available under the
+// terms of the Eclipse Public License v. 2.0 which is available at
+// http://www.eclipse.org/legal/epl-2.0.
+//
+// This Source Code may also be made available under the following Secondary
+// Licenses when the conditions for such availability set forth in the Eclipse
+// Public License v. 2.0 are satisfied: GNU General Public License, version 2
+// with the GNU Classpath Exception which is available at
+// https://www.gnu.org/software/classpath/license.html.
+//
+// SPDX-License-Identifier: EPL-2.0 OR GPL-2.0-only WITH Classpath-exception-2.0
+// *****************************************************************************
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+// based on https://github.com/microsoft/vscode/blob/04c36be045a94fee58e5f8992d3e3fd980294a84/src/vs/platform/files/node/diskFileSystemProvider.ts
+
+/* eslint-disable no-null/no-null */
+
+import { inject, injectable } from '@theia/core/shared/inversify';
+import {
+    FileChange, FileDeleteOptions, FileOpenOptions,
+    FileOverwriteOptions, FileReadStreamOptions, FileSystemProviderCapabilities,
+    FileSystemProviderError,
+    FileSystemProviderErrorCode,
+    FileSystemProviderWithFileReadWriteCapability,
+    FileType, FileUpdateOptions, FileUpdateResult, FileWriteOptions, Stat, WatchOptions, createFileSystemProviderError
+} from '../common/files';
+import { Event, URI, Disposable, CancellationToken } from '@theia/core';
+import { TextDocumentContentChangeEvent } from '@theia/core/shared/vscode-languageserver-protocol';
+import { ReadableStreamEvents } from '@theia/core/lib/common/stream';
+import { BFSRequire } from 'browserfs';
+import type { FSModule } from 'browserfs/dist/node/core/FS';
+import type { FileSystem } from 'browserfs/dist/node/core/file_system';
+import MountableFileSystem from 'browserfs/dist/node/backend/MountableFileSystem';
+import { basename, dirname, normalize } from 'path';
+import Stats from 'browserfs/dist/node/core/node_fs_stats';
+import { retry } from '@theia/core/lib/common/promise-util';
+import { BrowserFSInitialization } from './browserfs-filesystem-initialization';
+
+// adapted from DiskFileSystemProvider
+@injectable()
+export class BrowserFSFileSystemProvider implements FileSystemProviderWithFileReadWriteCapability {
+    capabilities: FileSystemProviderCapabilities = FileSystemProviderCapabilities.FileReadWrite;
+    onDidChangeCapabilities: Event<void> = Event.None;
+    onDidChangeFile: Event<readonly FileChange[]> = Event.None;
+    onFileWatchError: Event<void> = Event.None;
+    private mapHandleToPos: Map<number, number> = new Map();
+    private writeHandles: Set<number> = new Set();
+    private canFlush: boolean = true;
+
+    private fs: FSModule;
+    private mountableFS: MountableFileSystem;
+    private initialized: Promise<true>;
+
+    constructor(@inject(BrowserFSInitialization) readonly initialization: BrowserFSInitialization) {
+        const init = async (): Promise<true> => {
+            this.mountableFS = await initialization.createMountableFileSystem();
+            this.fs = BFSRequire('fs');
+            await initialization.initializeFS(this.fs, new Proxy(this, {
+                get(target, prop, receiver): unknown {
+                    if (prop === 'initialized') {
+                        return Promise.resolve(true);
+                    }
+                    return Reflect.get(target, prop, receiver);
+                }
+            }));
+            return true;
+        };
+        this.initialized = init();
+    }
+
+    async mount(mountPoint: string, fs: FileSystem): Promise<void> {
+        await this.initialized;
+        this.mountableFS.mount(mountPoint, fs);
+    };
+
+    watch(_resource: URI, _opts: WatchOptions): Disposable {
+        return Disposable.NULL;
+    }
+    async stat(resource: URI): Promise<Stat> {
+        await this.initialized;
+        const path = this.toFilePath(resource);
+
+        let stats: Stats;
+        try {
+            stats = await this.promisify(this.fs.stat)(path) as Stats;
+        } catch (error) {
+            throw this.toFileSystemProviderError(error);
+        }
+        if (stats === undefined) {
+            throw new Error(`Could not read file stat for resource '${path}'`);
+        }
+        return {
+            type: this.toType(stats, /* symbolicLink */undefined), // FIXME: missing symbolicLink
+            ctime: stats.birthtime.getTime(), // intentionally not using ctime here, we want the creation time
+            mtime: stats.mtime.getTime(),
+            size: stats.size,
+            // FIXME: missing mode, permissions
+        };
+
+    }
+    async mkdir(resource: URI): Promise<void> {
+        await this.initialized;
+        try {
+            await this.promisify(this.fs.mkdir)(this.toFilePath(resource));
+        } catch (error) {
+            throw this.toFileSystemProviderError(error);
+        }
+    }
+    async readdir(resource: URI): Promise<[string, FileType][]> {
+        await this.initialized;
+        try {
+
+            const children = await this.promisify(this.fs.readdir)(this.toFilePath(resource)) as string[];
+            const result: [string, FileType][] = [];
+            await Promise.all(children.map(async child => {
+                try {
+                    const stat = await this.stat(resource.resolve(child));
+                    result.push([child, stat.type]);
+                } catch (error) {
+                    console.trace(error); // ignore errors for individual entries that can arise from permission denied
+                }
+            }));
+
+            return result;
+        } catch (error) {
+            throw this.toFileSystemProviderError(error);
+        }
+    }
+    async delete(resource: URI, _opts: FileDeleteOptions): Promise<void> {
+        await this.initialized;
+        // FIXME use options
+        try {
+            await this.promisify(this.fs.unlink)(this.toFilePath(resource));
+        } catch (error) {
+            throw this.toFileSystemProviderError(error);
+        }
+    }
+    async rename(from: URI, to: URI, opts: FileOverwriteOptions): Promise<void> {
+        await this.initialized;
+        const fromFilePath = this.toFilePath(from);
+        const toFilePath = this.toFilePath(to);
+        if (fromFilePath === toFilePath) {
+            return; // simulate node.js behaviour here and do a no-op if paths match
+        }
+        try {
+            // assume FS is path case sensitive - correct?
+            const targetExists = await this.promisify(this.fs.exists)(toFilePath);
+            if (targetExists) {
+                throw Error(`File '${toFilePath}' already exists.`);
+            }
+            if (fromFilePath === toFilePath) {
+                return Promise.resolve();
+            }
+
+            await this.promisify(this.fs.rename)(fromFilePath, toFilePath);
+
+            const stat = await this.promisify(this.fs.lstat)(toFilePath) as Stats;
+            if (stat.isDirectory() || stat.isSymbolicLink()) {
+                return Promise.resolve(); // only for files
+            }
+            const fd = await this.promisify(open)(toFilePath, 'a');
+            try {
+                await this.promisify(this.fs.futimes)(fd, stat.atime, new Date());
+            } catch (error) {
+                // ignore
+            }
+
+            this.promisify(this.fs.close)(fd);
+        } catch (error) {
+            // rewrite some typical errors that can happen especially around symlinks
+            // to something the user can better understand
+            if (error.code === 'EINVAL' || error.code === 'EBUSY' || error.code === 'ENAMETOOLONG') {
+                error = new Error(`Unable to move '${basename(fromFilePath)}' into '${basename(dirname(toFilePath))}' (${error.toString()}).`);
+            }
+
+            throw this.toFileSystemProviderError(error);
+        }
+    }
+    async copy?(from: URI, to: URI, opts: FileOverwriteOptions): Promise<void> {
+        await this.initialized;
+        throw new Error('Method not implemented.');
+    }
+    async readFile(resource: URI): Promise<Uint8Array> {
+        await this.initialized;
+        try {
+            const filePath = this.toFilePath(resource);
+            return await this.promisify(this.fs.readFile)(filePath) as Uint8Array;
+        } catch (error) {
+            throw this.toFileSystemProviderError(error);
+        }
+    }
+    async writeFile(resource: URI, content: Uint8Array, opts: FileWriteOptions): Promise<void> {
+        await this.initialized;
+        let handle: number | undefined = undefined;
+        try {
+            const filePath = this.toFilePath(resource);
+
+            // Validate target unless { create: true, overwrite: true }
+            if (!opts.create || !opts.overwrite) {
+                const fileExists = await this.promisify(this.fs.exists)(filePath);
+                if (fileExists) {
+                    if (!opts.overwrite) {
+                        throw createFileSystemProviderError('File already exists', FileSystemProviderErrorCode.FileExists);
+                    }
+                } else {
+                    if (!opts.create) {
+                        throw createFileSystemProviderError('File does not exist', FileSystemProviderErrorCode.FileNotFound);
+                    }
+                }
+            }
+
+            // Open
+            handle = await this.open(resource, { create: true });
+
+            // Write content at once
+            await this.write(handle, 0, content, 0, content.byteLength);
+        } catch (error) {
+            throw this.toFileSystemProviderError(error);
+        } finally {
+            if (typeof handle === 'number') {
+                await this.close(handle);
+            }
+        }
+    }
+    readFileStream?(resource: URI, opts: FileReadStreamOptions, token: CancellationToken): ReadableStreamEvents<Uint8Array> {
+        throw new Error('Method not implemented.');
+    }
+    async open(resource: URI, opts: FileOpenOptions): Promise<number> {
+        await this.initialized;
+        try {
+            const filePath = this.toFilePath(resource);
+
+            let flags: string | undefined = undefined;
+            if (opts.create) {
+                // we take opts.create as a hint that the file is opened for writing
+                // as such we use 'w' to truncate an existing or create the
+                // file otherwise. we do not allow reading.
+                if (!flags) {
+                    flags = 'w';
+                }
+            } else {
+                // otherwise we assume the file is opened for reading
+                // as such we use 'r' to neither truncate, nor create
+                // the file.
+                flags = 'r';
+            }
+
+            const handle = await this.promisify(this.fs.open)(filePath, flags) as number;
+
+            // remember this handle to track file position of the handle
+            // we init the position to 0 since the file descriptor was
+            // just created and the position was not moved so far (see
+            // also http://man7.org/linux/man-pages/man2/open.2.html -
+            // "The file offset is set to the beginning of the file.")
+            this.mapHandleToPos.set(handle, 0);
+
+            // remember that this handle was used for writing
+            if (opts.create) {
+                this.writeHandles.add(handle);
+            }
+
+            return handle;
+        } catch (error) {
+            throw this.toFileSystemProviderError(error);
+        }
+    }
+    async close(fd: number): Promise<void> {
+        await this.initialized;
+        // remove this handle from map of positions
+        this.mapHandleToPos.delete(fd);
+
+        // if a handle is closed that was used for writing, ensure
+        // to flush the contents to disk if possible.
+        if (this.writeHandles.delete(fd) && this.canFlush) {
+            try {
+                await this.promisify(this.fs.fdatasync)(fd);
+            } catch (error) {
+                // In some exotic setups it is well possible that node fails to sync
+                // In that case we disable flushing and log the error to our logger
+                this.canFlush = false;
+                console.error(error);
+            }
+        }
+
+        await this.promisify(this.fs.close)(fd);
+    }
+    async read(fd: number, pos: number, data: Uint8Array, offset: number, length: number): Promise<number> {
+        await this.initialized;
+        const normalizedPos = this.normalizePos(fd, pos);
+
+        let bytesRead: number | null = null;
+        try {
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            const result: { bytesRead: number, buffer: Uint8Array } | number = (await this.promisify(this.fs.read)(fd, data, offset, length, normalizedPos)) as any;
+
+            if (typeof result === 'number') {
+                bytesRead = result; // node.d.ts fail
+            } else {
+                bytesRead = result.bytesRead;
+            }
+
+            return bytesRead;
+        } catch (error) {
+            throw this.toFileSystemProviderError(error);
+        } finally {
+            this.updatePos(fd, normalizedPos, bytesRead);
+        }
+    }
+    async write(fd: number, pos: number, data: Uint8Array, offset: number, length: number): Promise<number> {
+        await this.initialized;
+        // we know at this point that the file to write to is truncated and thus empty
+        // if the write now fails, the file remains empty. as such we really try hard
+        // to ensure the write succeeds by retrying up to three times.
+        return retry(() => this.doWrite(fd, pos, data, offset, length), 100 /* ms delay */, 3 /* retries */);
+
+    }
+    private async doWrite(fd: number, pos: number, data: Uint8Array, offset: number, length: number): Promise<number> {
+        await this.initialized;
+        const normalizedPos = this.normalizePos(fd, pos);
+
+        let bytesWritten: number | null = null;
+        try {
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            const result: { bytesWritten: number, buffer: Uint8Array } | number = (await this.promisify(this.fs.write)(fd, data, offset, length, normalizedPos)) as any;
+
+            if (typeof result === 'number') {
+                bytesWritten = result; // node.d.ts fail
+            } else {
+                bytesWritten = result.bytesWritten;
+            }
+
+            return bytesWritten;
+        } catch (error) {
+            throw this.toFileSystemProviderError(error);
+        } finally {
+            this.updatePos(fd, normalizedPos, bytesWritten);
+        }
+    }
+    private normalizePos(fd: number, pos: number): number | null {
+
+        // when calling fs.read/write we try to avoid passing in the "pos" argument and
+        // rather prefer to pass in "null" because this avoids an extra seek(pos)
+        // call that in some cases can even fail (e.g. when opening a file over FTP -
+        // see https://github.com/microsoft/vscode/issues/73884).
+        //
+        // as such, we compare the passed in position argument with our last known
+        // position for the file descriptor and use "null" if they match.
+        if (pos === this.mapHandleToPos.get(fd)) {
+            return null;
+        }
+
+        return pos;
+    }
+    private updatePos(fd: number, pos: number | null, bytesLength: number | null): void {
+        const lastKnownPos = this.mapHandleToPos.get(fd);
+        if (typeof lastKnownPos === 'number') {
+
+            // pos !== null signals that previously a position was used that is
+            // not null. node.js documentation explains, that in this case
+            // the internal file pointer is not moving and as such we do not move
+            // our position pointer.
+            //
+            // Docs: "If position is null, data will be read from the current file position,
+            // and the file position will be updated. If position is an integer, the file position
+            // will remain unchanged."
+            if (typeof pos === 'number') {
+                // do not modify the position
+            } else if (typeof bytesLength === 'number') {
+                this.mapHandleToPos.set(fd, lastKnownPos + bytesLength);
+            } else {
+                this.mapHandleToPos.delete(fd);
+            }
+        }
+    }
+    async access?(resource: URI, mode?: number | undefined): Promise<void> {
+        await this.initialized;
+        throw new Error('Method not implemented.');
+    }
+    async fsPath?(resource: URI): Promise<string> {
+        await this.initialized;
+        throw new Error('Method not implemented.');
+    }
+    async updateFile?(resource: URI, changes: TextDocumentContentChangeEvent[], opts: FileUpdateOptions): Promise<FileUpdateResult> {
+        await this.initialized;
+        throw new Error('Method not implemented.');
+    }
+
+    private toFilePath(resource: URI): string {
+        return normalize(resource.path.toString());
+    }
+
+    private toType(entry: Stats, symbolicLink?: { dangling: boolean }): FileType {
+        // Signal file type by checking for file / directory, except:
+        // - symbolic links pointing to non-existing files are FileType.Unknown
+        // - files that are neither file nor directory are FileType.Unknown
+        let type: FileType;
+        if (symbolicLink?.dangling) {
+            type = FileType.Unknown;
+        } else if (entry.isFile()) {
+            type = FileType.File;
+        } else if (entry.isDirectory()) {
+            type = FileType.Directory;
+        } else {
+            type = FileType.Unknown;
+        }
+
+        // Always signal symbolic link as file type additionally
+        if (symbolicLink) {
+            type |= FileType.SymbolicLink;
+        }
+
+        return type;
+    }
+
+    // FIXME typing
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    private promisify<T>(f: Function): (...args: any[]) => Promise<T> {
+        // eslint-disable-next-line @typescript-eslint/tslint/config, @typescript-eslint/no-explicit-any
+        return function (...args: any[]) {
+            return new Promise((resolve, reject) => {
+                // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                f(...args, (err: Error, result: T) => err ? reject(err) : resolve(result));
+            });
+        };
+    }
+
+    private toFileSystemProviderError(error: NodeJS.ErrnoException): FileSystemProviderError {
+        if (error instanceof FileSystemProviderError) {
+            return error; // avoid double conversion
+        }
+
+        let code: FileSystemProviderErrorCode;
+        switch (error.code) {
+            case 'ENOENT':
+                code = FileSystemProviderErrorCode.FileNotFound;
+                break;
+            case 'EISDIR':
+                code = FileSystemProviderErrorCode.FileIsADirectory;
+                break;
+            case 'ENOTDIR':
+                code = FileSystemProviderErrorCode.FileNotADirectory;
+                break;
+            case 'EEXIST':
+                code = FileSystemProviderErrorCode.FileExists;
+                break;
+            case 'EPERM':
+            case 'EACCES':
+                code = FileSystemProviderErrorCode.NoPermissions;
+                break;
+            default:
+                code = FileSystemProviderErrorCode.Unknown;
+        }
+
+        return createFileSystemProviderError(error, code);
+    }
+}

package/src/common/files.ts

@@ -27,6 +27,7 @@ import type { TextDocumentContentChangeEvent } from '@theia/core/shared/vscode-l
 import { ReadableStreamEvents } from '@theia/core/lib/common/stream';
 import { CancellationToken } from '@theia/core/lib/common/cancellation';
 import { isObject } from '@theia/core/lib/common';
+import { MarkdownString } from '@theia/core/lib/common/markdown-rendering';
 
 export const enum FileOperation {
     CREATE,
@@ -765,6 +766,18 @@ export function hasUpdateCapability(provider: FileSystemProvider): provider is F
     return !!(provider.capabilities & FileSystemProviderCapabilities.Update);
 }
 
+export interface ReadOnlyMessageFileSystemProvider {
+    readOnlyMessage: MarkdownString | undefined;
+    readonly onDidChangeReadOnlyMessage: Event<MarkdownString | undefined>;
+}
+
+export namespace ReadOnlyMessageFileSystemProvider {
+    export function is(arg: unknown): arg is ReadOnlyMessageFileSystemProvider {
+        return isObject<ReadOnlyMessageFileSystemProvider>(arg)
+        && 'readOnlyMessage' in arg;
+    }
+}
+
 /**
  * Subtype of {@link FileSystemProvider} that ensures that the optional functions, needed for providers
  * that should be able to read & write files, are implemented.

package/src/common/remote-file-system-provider.ts

@@ -23,7 +23,8 @@ import {
     FileWriteOptions, FileOpenOptions, FileChangeType,
     FileSystemProviderCapabilities, FileChange, Stat, FileOverwriteOptions, WatchOptions, FileType, FileSystemProvider, FileDeleteOptions,
     hasOpenReadWriteCloseCapability, hasFileFolderCopyCapability, hasReadWriteCapability, hasAccessCapability,
-    FileSystemProviderError, FileSystemProviderErrorCode, FileUpdateOptions, hasUpdateCapability, FileUpdateResult, FileReadStreamOptions, hasFileReadStreamCapability
+    FileSystemProviderError, FileSystemProviderErrorCode, FileUpdateOptions, hasUpdateCapability, FileUpdateResult, FileReadStreamOptions, hasFileReadStreamCapability,
+    ReadOnlyMessageFileSystemProvider
 } from './files';
 import { RpcServer, RpcProxy, RpcProxyFactory } from '@theia/core/lib/common/messaging/proxy-factory';
 import { ApplicationError } from '@theia/core/lib/common/application-error';
@@ -31,6 +32,7 @@ import { Deferred } from '@theia/core/lib/common/promise-util';
 import type { TextDocumentContentChangeEvent } from '@theia/core/shared/vscode-languageserver-protocol';
 import { newWriteableStream, ReadableStreamEvents } from '@theia/core/lib/common/stream';
 import { CancellationToken, cancelled } from '@theia/core/lib/common/cancellation';
+import { MarkdownString } from '@theia/core/lib/common/markdown-rendering';
 
 export const remoteFileSystemPath = '/services/remote-filesystem';
 
@@ -38,6 +40,7 @@ export const RemoteFileSystemServer = Symbol('RemoteFileSystemServer');
 export interface RemoteFileSystemServer extends RpcServer<RemoteFileSystemClient> {
     getCapabilities(): Promise<FileSystemProviderCapabilities>
     stat(resource: string): Promise<Stat>;
+    getReadOnlyMessage(): Promise<MarkdownString | undefined>;
     access(resource: string, mode?: number): Promise<void>;
     fsPath(resource: string): Promise<string>;
     open(resource: string, opts: FileOpenOptions): Promise<number>;
@@ -70,6 +73,7 @@ export interface RemoteFileSystemClient {
     notifyDidChangeFile(event: { changes: RemoteFileChange[] }): void;
     notifyFileWatchError(): void;
     notifyDidChangeCapabilities(capabilities: FileSystemProviderCapabilities): void;
+    notifyDidChangeReadOnlyMessage(readOnlyMessage: MarkdownString | undefined): void;
     onFileStreamData(handle: number, data: Uint8Array): void;
     onFileStreamEnd(handle: number, error: RemoteFileStreamError | undefined): void;
 }
@@ -109,7 +113,7 @@ export class RemoteFileSystemProxyFactory<T extends object> extends RpcProxyFact
  * Wraps the remote filesystem provider living on the backend.
  */
 @injectable()
-export class RemoteFileSystemProvider implements Required<FileSystemProvider>, Disposable {
+export class RemoteFileSystemProvider implements Required<FileSystemProvider>, Disposable, ReadOnlyMessageFileSystemProvider {
 
     private readonly onDidChangeFileEmitter = new Emitter<readonly FileChange[]>();
     readonly onDidChangeFile = this.onDidChangeFileEmitter.event;
@@ -120,6 +124,9 @@ export class RemoteFileSystemProvider implements Required<FileSystemProvider>, D
     private readonly onDidChangeCapabilitiesEmitter = new Emitter<void>();
     readonly onDidChangeCapabilities = this.onDidChangeCapabilitiesEmitter.event;
 
+    private readonly onDidChangeReadOnlyMessageEmitter = new Emitter<MarkdownString | undefined>();
+    readonly onDidChangeReadOnlyMessage = this.onDidChangeReadOnlyMessageEmitter.event;
+
     private readonly onFileStreamDataEmitter = new Emitter<[number, Uint8Array]>();
     private readonly onFileStreamData = this.onFileStreamDataEmitter.event;
 
@@ -129,6 +136,7 @@ export class RemoteFileSystemProvider implements Required<FileSystemProvider>, D
     protected readonly toDispose = new DisposableCollection(
         this.onDidChangeFileEmitter,
         this.onDidChangeCapabilitiesEmitter,
+        this.onDidChangeReadOnlyMessageEmitter,
         this.onFileStreamDataEmitter,
         this.onFileStreamEndEmitter
     );
@@ -146,6 +154,11 @@ export class RemoteFileSystemProvider implements Required<FileSystemProvider>, D
     private _capabilities: FileSystemProviderCapabilities = 0;
     get capabilities(): FileSystemProviderCapabilities { return this._capabilities; }
 
+    private _readOnlyMessage: MarkdownString | undefined = undefined;
+    get readOnlyMessage(): MarkdownString | undefined {
+        return this._readOnlyMessage;
+    }
+
     protected readonly readyDeferred = new Deferred<void>();
     readonly ready = this.readyDeferred.promise;
 
@@ -161,6 +174,9 @@ export class RemoteFileSystemProvider implements Required<FileSystemProvider>, D
             this._capabilities = capabilities;
             this.readyDeferred.resolve();
         }, this.readyDeferred.reject);
+        this.server.getReadOnlyMessage().then(readOnlyMessage => {
+            this._readOnlyMessage = readOnlyMessage;
+        });
         this.server.setClient({
             notifyDidChangeFile: ({ changes }) => {
                 this.onDidChangeFileEmitter.fire(changes.map(event => ({ resource: new URI(event.resource), type: event.type })));
@@ -169,6 +185,7 @@ export class RemoteFileSystemProvider implements Required<FileSystemProvider>, D
                 this.onFileWatchErrorEmitter.fire();
             },
             notifyDidChangeCapabilities: capabilities => this.setCapabilities(capabilities),
+            notifyDidChangeReadOnlyMessage: readOnlyMessage => this.setReadOnlyMessage(readOnlyMessage),
             onFileStreamData: (handle, data) => this.onFileStreamDataEmitter.fire([handle, data]),
             onFileStreamEnd: (handle, error) => this.onFileStreamEndEmitter.fire([handle, error])
         });
@@ -188,6 +205,11 @@ export class RemoteFileSystemProvider implements Required<FileSystemProvider>, D
         this.onDidChangeCapabilitiesEmitter.fire(undefined);
     }
 
+    protected setReadOnlyMessage(readOnlyMessage: MarkdownString | undefined): void {
+        this._readOnlyMessage = readOnlyMessage;
+        this.onDidChangeReadOnlyMessageEmitter.fire(readOnlyMessage);
+    }
+
     // --- forwarding calls
 
     stat(resource: URI): Promise<Stat> {
@@ -362,6 +384,14 @@ export class FileSystemProviderServer implements RemoteFileSystemServer {
                 this.client.notifyDidChangeCapabilities(this.provider.capabilities);
             }
         }));
+        if (ReadOnlyMessageFileSystemProvider.is(this.provider)) {
+            const providerWithReadOnlyMessage: ReadOnlyMessageFileSystemProvider = this.provider;
+            this.toDispose.push(this.provider.onDidChangeReadOnlyMessage(() => {
+                if (this.client) {
+                    this.client.notifyDidChangeReadOnlyMessage(providerWithReadOnlyMessage.readOnlyMessage);
+                }
+            }));
+        }
         this.toDispose.push(this.provider.onDidChangeFile(changes => {
             if (this.client) {
                 this.client.notifyDidChangeFile({
@@ -380,6 +410,14 @@ export class FileSystemProviderServer implements RemoteFileSystemServer {
         return this.provider.capabilities;
     }
 
+    async getReadOnlyMessage(): Promise<MarkdownString | undefined> {
+        if (ReadOnlyMessageFileSystemProvider.is(this.provider)) {
+            return this.provider.readOnlyMessage;
+        } else {
+            return undefined;
+        }
+    }
+
     stat(resource: string): Promise<Stat> {
         return this.provider.stat(new URI(resource));
     }