@theia/filesystem 1.26.0-next.41 → 1.26.0-next.45

package/src/browser/filesystem-frontend-module.ts

@@ -21,21 +21,14 @@ import { ResourceResolver, CommandContribution } from '@theia/core/lib/common';
 import { WebSocketConnectionProvider, FrontendApplicationContribution, LabelProviderContribution, BreadcrumbsContribution } from '@theia/core/lib/browser';
 import { FileResourceResolver } from './file-resource';
 import { bindFileSystemPreferences } from './filesystem-preferences';
-import { FileSystemWatcher } from './filesystem-watcher';
 import { FileSystemFrontendContribution } from './filesystem-frontend-contribution';
 import { FileUploadService } from './file-upload-service';
 import { FileTreeDecoratorAdapter, FileTreeLabelProvider } from './file-tree';
 import { FileService, FileServiceContribution } from './file-service';
 import { RemoteFileSystemProvider, RemoteFileSystemServer, remoteFileSystemPath, RemoteFileSystemProxyFactory } from '../common/remote-file-system-provider';
-import { FileSystem, FileStat, FileMoveOptions, FileDeleteOptions, FileSystemError } from '../common/filesystem';
-import URI from '@theia/core/lib/common/uri';
-import { FileOperationError, FileOperationResult, BaseStatWithMetadata, FileStatWithMetadata, etag } from '../common/files';
-import { TextDocumentContentChangeEvent } from '@theia/core/shared/vscode-languageserver-protocol';
-import { EnvVariablesServer } from '@theia/core/lib/common/env-variables';
 import { bindContributionProvider } from '@theia/core/lib/common/contribution-provider';
 import { RemoteFileServiceContribution } from './remote-file-service-contribution';
 import { FileSystemWatcherErrorHandler } from './filesystem-watcher-error-handler';
-import { UTF8 } from '@theia/core/lib/common/encodings';
 import { FilepathBreadcrumbsContribution } from './breadcrumbs/filepath-breadcrumbs-contribution';
 import { BreadcrumbsFileTreeWidget, createFileTreeBreadcrumbsWidget } from './breadcrumbs/filepath-breadcrumbs-container';
 import { FilesystemSaveResourceService } from './filesystem-save-resource-service';
@@ -54,163 +47,8 @@ export default new ContainerModule((bind, unbind, isBound, rebind) => {
     bind(RemoteFileServiceContribution).toSelf().inSingletonScope();
     bind(FileServiceContribution).toService(RemoteFileServiceContribution);
 
-    bind(FileSystemWatcher).toSelf().inSingletonScope();
     bind(FileSystemWatcherErrorHandler).toSelf().inSingletonScope();
 
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    bind(FileSystem).toDynamicValue(({ container }) => {
-        const fileService = container.get(FileService);
-        const environments = container.get<EnvVariablesServer>(EnvVariablesServer);
-        const convertStat: (stat: BaseStatWithMetadata | FileStatWithMetadata) => FileStat = stat => ({
-            uri: stat.resource.toString(),
-            lastModification: stat.mtime,
-            size: stat.size,
-            isDirectory: 'isDirectory' in stat && stat.isDirectory,
-            children: 'children' in stat ? stat.children?.map(convertStat) : undefined
-        });
-        // eslint-disable-next-line @typescript-eslint/no-explicit-any
-        const rethrowError: (uri: string, error: any) => never = (uri, error) => {
-            if (error instanceof FileOperationError) {
-                if (error.fileOperationResult === FileOperationResult.FILE_NOT_FOUND) {
-                    throw FileSystemError.FileNotFound(uri);
-                }
-                if (error.fileOperationResult === FileOperationResult.FILE_IS_DIRECTORY) {
-                    throw FileSystemError.FileIsDirectory(uri);
-                }
-                if (error.fileOperationResult === FileOperationResult.FILE_NOT_DIRECTORY) {
-                    throw FileSystemError.FileNotDirectory(uri);
-                }
-                if (error.fileOperationResult === FileOperationResult.FILE_MODIFIED_SINCE) {
-                    throw FileSystemError.FileIsOutOfSync(uri);
-                }
-            }
-            throw error;
-        };
-        return new class implements FileSystem {
-            async getFileStat(uri: string): Promise<FileStat | undefined> {
-                try {
-                    const stat = await fileService.resolve(new URI(uri), { resolveMetadata: true });
-                    return convertStat(stat);
-                } catch (e) {
-                    if (e instanceof FileOperationError && e.fileOperationResult === FileOperationResult.FILE_NOT_FOUND) {
-                        return undefined;
-                    }
-                    rethrowError(uri, e);
-                }
-            }
-            exists(uri: string): Promise<boolean> {
-                return fileService.exists(new URI(uri));
-            }
-            async resolveContent(uri: string, options?: { encoding?: string | undefined; } | undefined): Promise<{ stat: FileStat; content: string; }> {
-                try {
-                    const content = await fileService.read(new URI(uri), options);
-                    return {
-                        stat: convertStat(content),
-                        content: content.value
-                    };
-                } catch (e) {
-                    rethrowError(uri, e);
-                }
-            }
-            async setContent(file: FileStat, content: string, options?: { encoding?: string | undefined; } | undefined): Promise<FileStat> {
-                try {
-                    const result = await fileService.write(new URI(file.uri), content, {
-                        ...options,
-                        mtime: file.lastModification
-                    });
-                    return convertStat(result);
-                } catch (e) {
-                    rethrowError(file.uri, e);
-                }
-            }
-            async updateContent(file: FileStat, contentChanges: TextDocumentContentChangeEvent[], options?: {
-                encoding?: string | undefined;
-                overwriteEncoding?: string | undefined;
-            } | undefined): Promise<FileStat> {
-                try {
-                    const result = await fileService.update(new URI(file.uri), contentChanges, {
-                        mtime: file.lastModification,
-                        etag: etag({ size: file.size, mtime: file.lastModification }),
-                        readEncoding: options?.encoding || UTF8,
-                        encoding: options?.overwriteEncoding,
-                        overwriteEncoding: !!options?.overwriteEncoding
-                    });
-                    return convertStat(result);
-                } catch (e) {
-                    rethrowError(file.uri, e);
-                }
-            }
-            async move(sourceUri: string, targetUri: string, options?: FileMoveOptions | undefined): Promise<FileStat> {
-                try {
-                    const result = await fileService.move(new URI(sourceUri), new URI(targetUri), options);
-                    return convertStat(result);
-                } catch (e) {
-                    rethrowError(sourceUri, e);
-                }
-            }
-            async copy(sourceUri: string, targetUri: string, options?: { overwrite?: boolean | undefined; recursive?: boolean | undefined; } | undefined): Promise<FileStat> {
-                try {
-                    const result = await fileService.copy(new URI(sourceUri), new URI(targetUri), options);
-                    return convertStat(result);
-                } catch (e) {
-                    rethrowError(sourceUri, e);
-                }
-            }
-            async createFile(uri: string, options?: { content?: string | undefined; encoding?: string | undefined; } | undefined): Promise<FileStat> {
-                try {
-                    const result = await fileService.create(new URI(uri), options?.content, { encoding: options?.encoding });
-                    return convertStat(result);
-                } catch (e) {
-                    rethrowError(uri, e);
-                }
-            }
-            async createFolder(uri: string): Promise<FileStat> {
-                try {
-                    const result = await fileService.createFolder(new URI(uri));
-                    return convertStat(result);
-                } catch (e) {
-                    rethrowError(uri, e);
-                }
-            }
-            touchFile(uri: string): Promise<FileStat> {
-                throw new Error('Method not implemented.');
-            }
-            async delete(uri: string, options?: FileDeleteOptions | undefined): Promise<void> {
-                try {
-                    return await fileService.delete(new URI(uri), { useTrash: options?.moveToTrash, recursive: true });
-                } catch (e) {
-                    rethrowError(uri, e);
-                }
-            }
-            async getEncoding(uri: string): Promise<string> {
-                const { encoding } = await fileService.read(new URI(uri));
-                return encoding;
-            }
-            async guessEncoding(uri: string): Promise<string | undefined> {
-                const { encoding } = await fileService.read(new URI(uri), { autoGuessEncoding: true });
-                return encoding;
-            }
-            async getRoots(): Promise<FileStat[]> {
-                const drives = await environments.getDrives();
-                const roots = await Promise.all(drives.map(uri => this.getFileStat(uri)));
-                return roots.filter(root => !!root) as FileStat[];
-            }
-            async getCurrentUserHome(): Promise<FileStat | undefined> {
-                return this.getFileStat(await environments.getHomeDirUri());
-            }
-            getDrives(): Promise<string[]> {
-                return environments.getDrives();
-            }
-            access(uri: string, mode?: number | undefined): Promise<boolean> {
-                return fileService.access(new URI(uri), mode);
-            }
-            getFsPath(uri: string): Promise<string | undefined> {
-                return fileService.fsPath(new URI(uri));
-            }
-
-        };
-    }).inSingletonScope();
-
     bindFileResource(bind);
 
     bind(FileUploadService).toSelf().inSingletonScope();

package/src/browser/index.ts

@@ -18,5 +18,4 @@ export * from './location';
 export * from './file-tree';
 export * from './file-dialog';
 export * from './filesystem-preferences';
-export * from './filesystem-watcher';
 export * from './file-resource';

package/src/common/files.ts

@@ -846,7 +846,7 @@ export function hasOpenReadWriteCloseCapability(provider: FileSystemProvider): p
  */
 export interface FileSystemProviderWithFileReadStreamCapability extends FileSystemProvider {
     /**
-     * Read the contents of the given file as stream.
+     * Read the  contents of the given file as stream.
      * @param resource The `URI` of the file.
      *
      * @return The `ReadableStreamEvents` for the readable stream of the given file.

package/src/common/filesystem-watcher-protocol.ts

@@ -14,8 +14,7 @@
 // SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
 // *****************************************************************************
 
-import { injectable, inject } from '@theia/core/shared/inversify';
-import { JsonRpcServer, JsonRpcProxy } from '@theia/core';
+import { JsonRpcServer } from '@theia/core';
 import { FileChangeType } from './files';
 export { FileChangeType };
 
@@ -95,68 +94,3 @@ export interface FileChange {
     uri: string;
     type: FileChangeType;
 }
-
-export const FileSystemWatcherServerProxy = Symbol('FileSystemWatcherServerProxy');
-export type FileSystemWatcherServerProxy = JsonRpcProxy<FileSystemWatcherServer>;
-
-/**
- * @deprecated not used internally anymore.
- */
-@injectable()
-export class ReconnectingFileSystemWatcherServer implements FileSystemWatcherServer {
-
-    protected watcherSequence = 1;
-    protected readonly watchParams = new Map<number, {
-        uri: string;
-        options?: WatchOptions
-    }>();
-    protected readonly localToRemoteWatcher = new Map<number, number>();
-
-    constructor(
-        @inject(FileSystemWatcherServerProxy) protected readonly proxy: FileSystemWatcherServerProxy
-    ) {
-        const onInitialized = this.proxy.onDidOpenConnection(() => {
-            // skip reconnection on the first connection
-            onInitialized.dispose();
-            this.proxy.onDidOpenConnection(() => this.reconnect());
-        });
-    }
-
-    protected reconnect(): void {
-        for (const [watcher, { uri, options }] of this.watchParams.entries()) {
-            this.doWatchFileChanges(watcher, uri, options);
-        }
-    }
-
-    dispose(): void {
-        this.proxy.dispose();
-    }
-
-    watchFileChanges(uri: string, options?: WatchOptions): Promise<number> {
-        const watcher = this.watcherSequence++;
-        this.watchParams.set(watcher, { uri, options });
-        return this.doWatchFileChanges(watcher, uri, options);
-    }
-
-    protected doWatchFileChanges(watcher: number, uri: string, options?: WatchOptions): Promise<number> {
-        return this.proxy.watchFileChanges(uri, options).then(remote => {
-            this.localToRemoteWatcher.set(watcher, remote);
-            return watcher;
-        });
-    }
-
-    unwatchFileChanges(watcher: number): Promise<void> {
-        this.watchParams.delete(watcher);
-        const remote = this.localToRemoteWatcher.get(watcher);
-        if (remote) {
-            this.localToRemoteWatcher.delete(watcher);
-            return this.proxy.unwatchFileChanges(remote);
-        }
-        return Promise.resolve();
-    }
-
-    setClient(client: FileSystemWatcherClient | undefined): void {
-        this.proxy.setClient(client);
-    }
-
-}

package/src/common/filesystem.ts

@@ -14,179 +14,6 @@
 // SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
 // *****************************************************************************
 
-/* eslint-disable max-len */
-
-import { TextDocumentContentChangeEvent } from '@theia/core/shared/vscode-languageserver-protocol';
-import { ApplicationError } from '@theia/core/lib/common';
-
-/**
- * @deprecated since 1.4.0 - in order to support VS Code FS API (https://github.com/eclipse-theia/theia/pull/7908), use `FileService` instead
- */
-export const FileSystem = Symbol('FileSystem');
-export interface FileSystem {
-
-    /**
-     * Returns the file stat for the given URI.
-     *
-     * If the uri points to a folder it will contain one level of unresolved children.
-     *
-     * `undefined` if a file for the given URI does not exist.
-     *
-     * @deprecated since 1.4.0 - in order to support VS Code FS API (https://github.com/eclipse-theia/theia/pull/7908), use `FileService.resolve` instead
-     */
-    getFileStat(uri: string): Promise<FileStat | undefined>;
-
-    /**
-     * Finds out if a file identified by the resource exists.
-     *
-     * @deprecated since 1.4.0 - in order to support VS Code FS API (https://github.com/eclipse-theia/theia/pull/7908), use `FileService.exists` instead
-     */
-    exists(uri: string): Promise<boolean>;
-
-    /**
-     * Resolve the contents of a file identified by the resource.
-     *
-     * @deprecated since 1.4.0 - in order to support VS Code FS API (https://github.com/eclipse-theia/theia/pull/7908), use `FileService.read` instead
-     */
-    resolveContent(uri: string, options?: { encoding?: string }): Promise<{ stat: FileStat, content: string }>;
-
-    /**
-     * Updates the content replacing its previous value.
-     *
-     * @deprecated since 1.4.0 - in order to support VS Code FS API (https://github.com/eclipse-theia/theia/pull/7908), use `FileService.write` instead
-     */
-    setContent(file: FileStat, content: string, options?: { encoding?: string }): Promise<FileStat>;
-
-    /**
-     * Updates the content replacing its previous value.
-     *
-     * The optional parameter `overwriteEncoding` can be used to transform the encoding of a file.
-     *
-     * |   | encoding | overwriteEncoding | behaviour |
-     * |---|----------|-------------------|-----------|
-     * | 1 | undefined |    undefined     | read & write file in default encoding |
-     * | 2 | undefined |        ✓         | read file in default encoding; write file in `overwriteEncoding` |
-     * | 3 |     ✓    |     undefined     | read & write file in `encoding` |
-     * | 4 |     ✓    |        ✓         | read file in `encoding`; write file in `overwriteEncoding` |
-     *
-     * @deprecated since 1.4.0 - in order to support VS Code FS API (https://github.com/eclipse-theia/theia/pull/7908), use `FileService.write` instead
-     */
-    updateContent(file: FileStat, contentChanges: TextDocumentContentChangeEvent[], options?: { encoding?: string, overwriteEncoding?: string }): Promise<FileStat>;
-
-    /**
-     * Moves the file to a new path identified by the resource.
-     *
-     * The optional parameter overwrite can be set to replace an existing file at the location.
-     *
-     * |           | missing | file | empty dir |    dir    |
-     * |-----------|---------|------|-----------|-----------|
-     * | missing   |    x    |   x  |     x     |     x     |
-     * | file      |    ✓    |   x  |     x     |     x     |
-     * | empty dir |    ✓    |   x  |     x     | overwrite |
-     * | dir       |    ✓    |   x  | overwrite | overwrite |
-     *
-     * @deprecated since 1.4.0 - in order to support VS Code FS API (https://github.com/eclipse-theia/theia/pull/7908), use `FileService.move` instead
-     */
-    move(sourceUri: string, targetUri: string, options?: FileMoveOptions): Promise<FileStat>;
-
-    /**
-     * Copies the file to a path identified by the resource.
-     *
-     * The optional parameter overwrite can be set to replace an existing file at the location.
-     *
-     * @deprecated since 1.4.0 - in order to support VS Code FS API (https://github.com/eclipse-theia/theia/pull/7908), use `FileService.copy` instead
-     */
-    copy(sourceUri: string, targetUri: string, options?: { overwrite?: boolean, recursive?: boolean }): Promise<FileStat>;
-
-    /**
-     * Creates a new file with the given path. The returned promise
-     * will have the stat model object as a result.
-     *
-     * The optional parameter content can be used as value to fill into the new file.
-     *
-     * @deprecated since 1.4.0 - in order to support VS Code FS API (https://github.com/eclipse-theia/theia/pull/7908), use `FileService.create` instead
-     */
-    createFile(uri: string, options?: { content?: string, encoding?: string }): Promise<FileStat>;
-
-    /**
-     * Creates a new folder with the given path. The returned promise
-     * will have the stat model object as a result.
-     *
-     * @deprecated since 1.4.0 - in order to support VS Code FS API (https://github.com/eclipse-theia/theia/pull/7908), use `FileService.createFolder` instead
-     */
-    createFolder(uri: string): Promise<FileStat>;
-
-    /**
-     * Creates a new empty file if the given path does not exist and otherwise
-     * will set the mtime and atime of the file to the current date.
-     */
-    touchFile(uri: string): Promise<FileStat>;
-
-    /**
-     * Deletes the provided file. The optional moveToTrash parameter allows to
-     * move the file to trash.
-     *
-     * @deprecated since 1.4.0 - in order to support VS Code FS API (https://github.com/eclipse-theia/theia/pull/7908), use `FileService.delete` instead
-     */
-    delete(uri: string, options?: FileDeleteOptions): Promise<void>;
-
-    /**
-     * Returns the encoding of the given file resource.
-     *
-     * @deprecated since 1.4.0 - in order to support VS Code FS API (https://github.com/eclipse-theia/theia/pull/7908) use `FileService.read` without `autoGuessEncoding` option instead
-     */
-    getEncoding(uri: string): Promise<string>;
-
-    /**
-     * Guess encoding of a given file based on its content.
-     *
-     * @deprecated since 1.4.0 - in order to support VS Code FS API (https://github.com/eclipse-theia/theia/pull/7908), use `FileService.read` with `autoGuessEncoding` option instead
-     */
-    guessEncoding(uri: string): Promise<string | undefined>;
-
-    /**
-     * Return list of available roots.
-     */
-    getRoots(): Promise<FileStat[]>;
-
-    /**
-     * Returns a promise that resolves to a file stat representing the current user's home directory.
-     *
-     * @deprecated since 1.4.0 - in order to support VS Code FS API (https://github.com/eclipse-theia/theia/pull/7908), use `EnvVariablesServer.getHomeDirUri` instead
-     */
-    getCurrentUserHome(): Promise<FileStat | undefined>;
-
-    /**
-     * Resolves to an array of URIs pointing to the available drives on the filesystem.
-     *
-     * @deprecated since 1.4.0 - in order to support VS Code FS API (https://github.com/eclipse-theia/theia/pull/7908), use `EnvVariablesServer.getDrives` instead
-     */
-    getDrives(): Promise<string[]>;
-
-    /**
-     * Tests a user's permissions for the file or directory specified by URI.
-     * The mode argument is an optional integer that specifies the accessibility checks to be performed.
-     * Check `FileAccess.Constants` for possible values of mode.
-     * It is possible to create a mask consisting of the bitwise `OR` of two or more values (e.g. FileAccess.Constants.W_OK | FileAccess.Constants.R_OK).
-     * If `mode` is not defined, `FileAccess.Constants.F_OK` will be used instead.
-     *
-     * @deprecated since 1.4.0 - in order to support VS Code FS API (https://github.com/eclipse-theia/theia/pull/7908), use `FileService.access` instead
-     */
-    access(uri: string, mode?: number): Promise<boolean>
-
-    /**
-     * Returns the path of the given file URI, specific to the backend's operating system.
-     * If the URI is not a file URI, undefined is returned.
-     *
-     * USE WITH CAUTION: You should always prefer URIs to paths if possible, as they are
-     * portable and platform independent. Paths should only be used in cases you directly
-     * interact with the OS, e.g. when running a command on the shell.
-     *
-     * @deprecated since 1.4.0 - in order to support VS Code FS API (https://github.com/eclipse-theia/theia/pull/7908), use `FileService.fsPath` instead
-     */
-    getFsPath(uri: string): Promise<string | undefined>
-}
-
 export namespace FileAccess {
 
     export namespace Constants {
@@ -212,91 +39,5 @@ export namespace FileAccess {
          * This has no effect on Windows (will behave like `FileAccess.F_OK`).
          */
         export const X_OK: number = 1;
-
     }
-
-}
-
-export interface FileMoveOptions {
-    overwrite?: boolean;
-}
-
-export interface FileDeleteOptions {
-    moveToTrash?: boolean
-}
-
-/**
- * A file resource with meta information.
- *
- * @deprecated since 1.4.0 - in order to support VS Code FS API (https://github.com/eclipse-theia/theia/pull/7908), use `FileStat` from `@theia/filesystem/lib/common/files` instead
- */
-export interface FileStat {
-
-    /**
-     * The URI of the file.
-     */
-    uri: string;
-
-    /**
-     * The last modification of this file.
-     */
-    lastModification: number;
-
-    /**
-     * `true` if the resource is a directory. Otherwise, `false`.
-     */
-    isDirectory: boolean;
-
-    /**
-     * The children of the file stat.
-     * If it is `undefined` and `isDirectory` is `true`, then this file stat is unresolved.
-     */
-    children?: FileStat[];
-
-    /**
-     * The size of the file if known.
-     */
-    size?: number;
-
-}
-
-export namespace FileStat {
-    export function is(candidate: Object | undefined): candidate is FileStat {
-        return typeof candidate === 'object' && ('uri' in candidate) && ('lastModification' in candidate) && ('isDirectory' in candidate);
-    }
-
-    export function equals(one: object | undefined, other: object | undefined): boolean {
-        if (!one || !other || !is(one) || !is(other)) {
-            return false;
-        }
-        return one.uri === other.uri
-            && one.lastModification === other.lastModification
-            && one.isDirectory === other.isDirectory;
-    }
-}
-
-/**
- * @deprecated since 1.4.0 - in order to support VS Code FS API (https://github.com/eclipse-theia/theia/pull/7908), use `FileOperationError` instead
- */
-export namespace FileSystemError {
-    export const FileNotFound = ApplicationError.declare(-33000, (uri: string, prefix?: string) => ({
-        message: `${prefix ? prefix + ' ' : ''}'${uri}' has not been found.`,
-        data: { uri }
-    }));
-    export const FileExists = ApplicationError.declare(-33001, (uri: string, prefix?: string) => ({
-        message: `${prefix ? prefix + ' ' : ''}'${uri}' already exists.`,
-        data: { uri }
-    }));
-    export const FileIsDirectory = ApplicationError.declare(-33002, (uri: string, prefix?: string) => ({
-        message: `${prefix ? prefix + ' ' : ''}'${uri}' is a directory.`,
-        data: { uri }
-    }));
-    export const FileNotDirectory = ApplicationError.declare(-33003, (uri: string, prefix?: string) => ({
-        message: `${prefix ? prefix + ' ' : ''}'${uri}' is not a directory.`,
-        data: { uri }
-    }));
-    export const FileIsOutOfSync = ApplicationError.declare(-33004, (file: FileStat, stat: FileStat) => ({
-        message: `'${file.uri}' is out of sync.`,
-        data: { file, stat }
-    }));
 }

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

@@ -42,11 +42,11 @@ export interface RemoteFileSystemServer extends JsonRpcServer<RemoteFileSystemCl
     fsPath(resource: string): Promise<string>;
     open(resource: string, opts: FileOpenOptions): Promise<number>;
     close(fd: number): Promise<void>;
-    read(fd: number, pos: number, length: number): Promise<{ bytes: Uint8Array; bytesRead: number; }>;
+    read(fd: number, pos: number, length: number): Promise<{ bytes: number[]; bytesRead: number; }>;
     readFileStream(resource: string, opts: FileReadStreamOptions, token: CancellationToken): Promise<number>;
-    readFile(resource: string): Promise<Uint8Array>;
-    write(fd: number, pos: number, data: Uint8Array, offset: number, length: number): Promise<number>;
-    writeFile(resource: string, content: Uint8Array, opts: FileWriteOptions): Promise<void>;
+    readFile(resource: string): Promise<number[]>;
+    write(fd: number, pos: number, data: number[], offset: number, length: number): Promise<number>;
+    writeFile(resource: string, content: number[], opts: FileWriteOptions): Promise<void>;
     delete(resource: string, opts: FileDeleteOptions): Promise<void>;
     mkdir(resource: string): Promise<void>;
     readdir(resource: string): Promise<[string, FileType][]>;
@@ -70,7 +70,7 @@ export interface RemoteFileSystemClient {
     notifyDidChangeFile(event: { changes: RemoteFileChange[] }): void;
     notifyFileWatchError(): void;
     notifyDidChangeCapabilities(capabilities: FileSystemProviderCapabilities): void;
-    onFileStreamData(handle: number, data: Uint8Array): void;
+    onFileStreamData(handle: number, data: number[]): void;
     onFileStreamEnd(handle: number, error: RemoteFileStreamError | undefined): void;
 }
 
@@ -169,7 +169,7 @@ export class RemoteFileSystemProvider implements Required<FileSystemProvider>, D
                 this.onFileWatchErrorEmitter.fire();
             },
             notifyDidChangeCapabilities: capabilities => this.setCapabilities(capabilities),
-            onFileStreamData: (handle, data) => this.onFileStreamDataEmitter.fire([handle, data]),
+            onFileStreamData: (handle, data) => this.onFileStreamDataEmitter.fire([handle, Uint8Array.from(data)]),
             onFileStreamEnd: (handle, error) => this.onFileStreamEndEmitter.fire([handle, error])
         });
         const onInitialized = this.server.onDidOpenConnection(() => {
@@ -224,7 +224,7 @@ export class RemoteFileSystemProvider implements Required<FileSystemProvider>, D
 
     async readFile(resource: URI): Promise<Uint8Array> {
         const bytes = await this.server.readFile(resource.toString());
-        return bytes;
+        return Uint8Array.from(bytes);
     }
 
     readFileStream(resource: URI, opts: FileReadStreamOptions, token: CancellationToken): ReadableStreamEvents<Uint8Array> {
@@ -264,11 +264,11 @@ export class RemoteFileSystemProvider implements Required<FileSystemProvider>, D
     }
 
     write(fd: number, pos: number, data: Uint8Array, offset: number, length: number): Promise<number> {
-        return this.server.write(fd, pos, data, offset, length);
+        return this.server.write(fd, pos, [...data.values()], offset, length);
     }
 
     writeFile(resource: URI, content: Uint8Array, opts: FileWriteOptions): Promise<void> {
-        return this.server.writeFile(resource.toString(), content, opts);
+        return this.server.writeFile(resource.toString(), [...content.values()], opts);
     }
 
     delete(resource: URI, opts: FileDeleteOptions): Promise<void> {
@@ -412,33 +412,34 @@ export class FileSystemProviderServer implements RemoteFileSystemServer {
         throw new Error('not supported');
     }
 
-    async read(fd: number, pos: number, length: number): Promise<{ bytes: Uint8Array; bytesRead: number; }> {
+    async read(fd: number, pos: number, length: number): Promise<{ bytes: number[]; bytesRead: number; }> {
         if (hasOpenReadWriteCloseCapability(this.provider)) {
             const buffer = BinaryBuffer.alloc(this.BUFFER_SIZE);
             const bytes = buffer.buffer;
             const bytesRead = await this.provider.read(fd, pos, bytes, 0, length);
-            return { bytes, bytesRead };
+            return { bytes: [...bytes.values()], bytesRead };
         }
         throw new Error('not supported');
     }
 
-    write(fd: number, pos: number, data: Uint8Array, offset: number, length: number): Promise<number> {
+    write(fd: number, pos: number, data: number[], offset: number, length: number): Promise<number> {
         if (hasOpenReadWriteCloseCapability(this.provider)) {
-            return this.provider.write(fd, pos, data, offset, length);
+            return this.provider.write(fd, pos, Uint8Array.from(data), offset, length);
         }
         throw new Error('not supported');
     }
 
-    async readFile(resource: string): Promise<Uint8Array> {
+    async readFile(resource: string): Promise<number[]> {
         if (hasReadWriteCapability(this.provider)) {
-            return this.provider.readFile(new URI(resource));
+            const buffer = await this.provider.readFile(new URI(resource));
+            return [...buffer.values()];
         }
         throw new Error('not supported');
     }
 
-    writeFile(resource: string, content: Uint8Array, opts: FileWriteOptions): Promise<void> {
+    writeFile(resource: string, content: number[], opts: FileWriteOptions): Promise<void> {
         if (hasReadWriteCapability(this.provider)) {
-            return this.provider.writeFile(new URI(resource), content, opts);
+            return this.provider.writeFile(new URI(resource), Uint8Array.from(content), opts);
         }
         throw new Error('not supported');
     }
@@ -496,7 +497,7 @@ export class FileSystemProviderServer implements RemoteFileSystemServer {
         if (hasFileReadStreamCapability(this.provider)) {
             const handle = this.readFileStreamSeq++;
             const stream = this.provider.readFileStream(new URI(resource), opts, token);
-            stream.on('data', data => this.client?.onFileStreamData(handle, data));
+            stream.on('data', data => this.client?.onFileStreamData(handle, [...data.values()]));
             stream.on('error', error => {
                 const code = error instanceof FileSystemProviderError ? error.code : undefined;
                 const { name, message, stack } = error;