feat: use new filesystem requests

Author: Loïc Mangeonjean

src/customRequests.ts

@@ -6,40 +6,65 @@ export interface WillShutdownParams {
 }
 export const willShutdownNotificationType = new ProtocolNotificationType<WillShutdownParams, void>('willShutdown')
 
-export interface SaveTextDocumentParams {
-  textDocument: {
-    uri: string
-    text: string
-  }
+export interface WriteFileParams {
+  uri: string
+  content: string
 }
 
-export const saveTextDocumentRequestType = new ProtocolRequestType<SaveTextDocumentParams, void, never, void, void>('textDocument/save')
+export const writeFileRequestType = new ProtocolRequestType<WriteFileParams, void, never, void, void>('file/write')
 
-export interface GetTextDocumentParams {
-  textDocument: {
-    uri: string
-  }
+export interface ReadFileParams {
+  uri: string
 }
 
-export interface GetTextDocumentResult {
-  text: string
+export interface ReadFileResult {
+  content: string
 }
 
-export const getTextDocumentRequestType = new ProtocolRequestType<GetTextDocumentParams, GetTextDocumentResult, never, void, void>('textDocument/get')
+export const readFileRequestType = new ProtocolRequestType<ReadFileParams, ReadFileResult, never, void, void>('file/read')
 
-export function updateFile (uri: string, text: string, languageClient: LanguageClient): Promise<void> {
-  return languageClient.sendRequest(saveTextDocumentRequestType, {
-    textDocument: {
-      uri,
-      text
-    }
+export interface StatFileParams {
+  uri: string
+}
+export interface StatFileResult {
+  type: 'directory' | 'file'
+  size: number
+  name: string
+  mtime: number
+}
+
+export const getFileStatsRequestType = new ProtocolRequestType<StatFileParams, StatFileResult, never, void, void>('file/stats')
+
+export interface ListFilesParams {
+  directory: string
+}
+export interface ListFilesResult {
+  files: string[]
+}
+
+export const listFileRequestType = new ProtocolRequestType<ListFilesParams, ListFilesResult, never, void, void>('file/readdir')
+
+export function writeFile (uri: string, content: string, languageClient: LanguageClient): Promise<void> {
+  return languageClient.sendRequest(writeFileRequestType, {
+    uri,
+    content
+  })
+}
+
+export function readFile (uri: string, languageClient: LanguageClient): Promise<ReadFileResult> {
+  return languageClient.sendRequest(readFileRequestType, {
+    uri
+  })
+}
+
+export function getFileStats (uri: string, languageClient: LanguageClient): Promise<StatFileResult> {
+  return languageClient.sendRequest(getFileStatsRequestType, {
+    uri
   })
 }
 
-export function getFile (uri: string, languageClient: LanguageClient): Promise<{ text: string }> {
-  return languageClient.sendRequest(getTextDocumentRequestType, {
-    textDocument: {
-      uri
-    }
+export function listFiles (directory: string, languageClient: LanguageClient): Promise<ListFilesResult> {
+  return languageClient.sendRequest(listFileRequestType, {
+    directory
   })
 }

src/extensions.ts

@@ -10,6 +10,25 @@ import { Infrastructure } from './infrastructure'
 import { LanguageClientManager } from './languageClient'
 import { MonacoLanguageClient } from './createLanguageClient'
 
+async function bufferToBase64 (buffer: ArrayBuffer | Uint8Array) {
+  // use a FileReader to generate a base64 data URI:
+  const base64url = await new Promise<string>((resolve) => {
+    const reader = new FileReader()
+    reader.onload = () => resolve(reader.result as string)
+    reader.readAsDataURL(new Blob([buffer]))
+  })
+  // remove the `data:...;base64,` part from the start
+  return base64url.slice(base64url.indexOf(',') + 1)
+}
+
+async function base64ToBufferAsync (base64: string) {
+  const dataUrl = `data:application/octet-binary;base64,${base64}`
+
+  const result = await fetch(dataUrl)
+  const buffer = await result.arrayBuffer()
+  return new Uint8Array(buffer)
+}
+
 interface ResolvedTextDocumentSyncCapabilities {
   resolvedTextDocumentSync?: TextDocumentSyncOptions
 }
@@ -31,7 +50,7 @@ export class InitializeTextDocumentFeature implements StaticFeature {
     const languageClient = this.languageClient
     async function saveFile (textDocument: vscode.TextDocument) {
       if (documentSelector != null && vscode.languages.match(documentSelector, textDocument) > 0 && textDocument.uri.scheme === 'file') {
-        await infrastructure.saveFileContent?.(textDocument.uri, textDocument.getText(), languageClient)
+        await infrastructure.writeFile?.(textDocument.uri, btoa(textDocument.getText()), languageClient)
 
         // Always send notification even if the server doesn't support it (because csharp register the didSave feature too late)
         await languageClient.sendNotification(DidSaveTextDocumentNotification.type, {
@@ -76,30 +95,31 @@ export class WillDisposeFeature implements StaticFeature {
   clear (): void {}
 }
 
-const encoder = new TextEncoder()
-const decoder = new TextDecoder()
-class InfrastructureTextFileSystemProvider implements IFileSystemProviderWithFileReadWriteCapability {
+class InfrastructureFileSystemProvider implements IFileSystemProviderWithFileReadWriteCapability {
   capabilities = FileSystemProviderCapabilities.FileReadWrite | FileSystemProviderCapabilities.PathCaseSensitive | FileSystemProviderCapabilities.Readonly
   constructor (private infrastructure: Infrastructure, private languageClientManager: LanguageClientManager) {
   }
 
-  private cachedContent: Map<string, Promise<string | undefined>> = new Map()
-  private async getFileContent (resource: monaco.Uri): Promise<string | undefined> {
+  private isBlacklisted (resource: monaco.Uri) {
     const REMOTE_FILE_BLACKLIST = ['.git/config', '.vscode', monaco.Uri.parse(this.infrastructure.rootUri).path]
 
     const blacklisted = REMOTE_FILE_BLACKLIST.some(blacklisted => resource.path.endsWith(blacklisted))
-    if (blacklisted) {
-      return undefined
-    }
-    if (!this.cachedContent.has(resource.toString())) {
-      this.cachedContent.set(resource.toString(), this.infrastructure.getFileContent!(resource, this.languageClientManager))
-    }
-    return await this.cachedContent.get(resource.toString())
+    return blacklisted
   }
 
   async readFile (resource: monaco.Uri): Promise<Uint8Array> {
-    const content = await this.getFileContent(resource)
-    return encoder.encode(content)
+    if (this.isBlacklisted(resource)) {
+      throw FileSystemProviderError.create('Not allowed', FileSystemProviderErrorCode.NoPermissions)
+    }
+    try {
+      const file = await this.infrastructure.readFile!(resource, this.languageClientManager)
+      return await base64ToBufferAsync(file)
+    } catch (err) {
+      if ((err as Error).message === 'File not found') {
+        throw FileSystemProviderError.create(err as Error, FileSystemProviderErrorCode.FileNotFound)
+      }
+      throw FileSystemProviderError.create(err as Error, FileSystemProviderErrorCode.Unknown)
+    }
   }
 
   async writeFile (): Promise<void> {
@@ -116,16 +136,22 @@ class InfrastructureTextFileSystemProvider implements IFileSystemProviderWithFil
 
   async stat (resource: monaco.Uri): Promise<IStat> {
     try {
-      const content = await this.getFileContent(resource)
-      if (content != null) {
+      if (this.isBlacklisted(resource)) {
+        throw FileSystemProviderError.create('Not allowed', FileSystemProviderErrorCode.NoPermissions)
+      }
+      const fileStats = await this.infrastructure.getFileStats?.(resource, this.languageClientManager)
+      if (fileStats != null) {
         return {
-          type: FileType.File,
-          size: encoder.encode(content).length,
-          mtime: Date.now(),
-          ctime: Date.now()
+          type: fileStats.type === 'directory' ? FileType.Directory : FileType.File,
+          size: fileStats.size,
+          mtime: fileStats.mtime,
+          ctime: 0
         }
       }
     } catch (err) {
+      if ((err as Error).message === 'File not found') {
+        throw FileSystemProviderError.create(err as Error, FileSystemProviderErrorCode.FileNotFound)
+      }
       throw FileSystemProviderError.create(err as Error, FileSystemProviderErrorCode.Unknown)
     }
     throw FileSystemProviderError.create('file not found', FileSystemProviderErrorCode.FileNotFound)
@@ -134,8 +160,20 @@ class InfrastructureTextFileSystemProvider implements IFileSystemProviderWithFil
   async mkdir (): Promise<void> {
   }
 
-  async readdir () {
-    return []
+  async readdir (resource: monaco.Uri) {
+    const result = await this.infrastructure.listFiles?.(resource, this.languageClientManager)
+    if (result == null) {
+      return []
+    }
+    return result.map(file => {
+      let name = file
+      let type = FileType.File
+      if (file.endsWith('/')) {
+        type = FileType.Directory
+        name = file.slice(0, -1)
+      }
+      return <[string, FileType]>[name, type]
+    })
   }
 
   delete (): Promise<void> {
@@ -156,17 +194,17 @@ export class FileSystemFeature implements StaticFeature {
     const disposables = new DisposableStore()
 
     // Register readonly file system overlay to access remote files
-    if (this.infrastructure.getFileContent != null) {
-      disposables.add(registerFileSystemOverlay(-1, new InfrastructureTextFileSystemProvider(this.infrastructure, this.languageClientManager)))
+    if (this.infrastructure.readFile != null) {
+      disposables.add(registerFileSystemOverlay(-1, new InfrastructureFileSystemProvider(this.infrastructure, this.languageClientManager)))
     }
 
-    if (this.infrastructure.saveFileContent != null) {
+    if (this.infrastructure.writeFile != null) {
       const watcher = vscode.workspace.createFileSystemWatcher(new vscode.RelativePattern(vscode.Uri.parse(this.infrastructure.rootUri), '**/*'))
       disposables.add(watcher)
       const onFileChange = async (uri: vscode.Uri) => {
         if ((await vscode.workspace.fs.stat(uri)).type === vscode.FileType.File) {
           const content = await vscode.workspace.fs.readFile(uri)
-          await this.infrastructure.saveFileContent?.(uri, decoder.decode(content), this.languageClientManager)
+          await this.infrastructure.writeFile?.(uri, await bufferToBase64(content), this.languageClientManager)
         }
       }
       watcher.onDidChange(onFileChange)

src/infrastructure.ts

@@ -3,7 +3,7 @@ import { MessageTransports } from 'vscode-languageclient'
 import * as monaco from 'monaco-editor'
 import * as vscode from 'vscode'
 import { LSPAny } from 'vscode-languageserver-protocol'
-import { getFile, updateFile } from './customRequests'
+import { StatFileResult, getFileStats, listFiles, writeFile, readFile } from './customRequests'
 import { LanguageClientManager } from './languageClient'
 import { LanguageClientId, LanguageClientOptions } from './languageClientOptions'
 
@@ -31,16 +31,28 @@ export interface Infrastructure {
   /**
    * Save a file on the filesystem
    * @param document The document to save
-   * @param reason The reason of the save
+   * @param content The content of the file in base64
    * @param languageClient The languageclient we're trying to save the file to
    */
-  saveFileContent? (document: monaco.Uri, content: string, languageClient: LanguageClientManager): Promise<void>
+  writeFile? (document: monaco.Uri, content: string, languageClient: LanguageClientManager): Promise<void>
   /**
-   * Get a text file content as a model
+   * Get a text file content
    * @param resource the Uri of the file
    * @param languageClient The languageclient we're trying to get the file from
    */
-  getFileContent? (resource: monaco.Uri, languageClient: LanguageClientManager): Promise<string | undefined>
+  readFile? (resource: monaco.Uri, languageClient: LanguageClientManager): Promise<string>
+  /**
+   * Get file stats on a given file
+   * @param resource the Uri of the file
+   * @param languageClient The languageclient we're trying to get the file from
+   */
+  getFileStats? (resource: monaco.Uri, languageClient: LanguageClientManager): Promise<StatFileResult>
+  /**
+   * List the files of a directory
+   * @param resource the Uri of the directory
+   * @param languageClient The languageclient we're trying to get the file from
+   */
+  listFiles? (resource: monaco.Uri, languageClient: LanguageClientManager): Promise<string[]>
 
   /**
    * Open a connection to the language server
@@ -106,17 +118,25 @@ export abstract class CodinGameInfrastructure implements Infrastructure {
     name: 'main'
   }]
 
-  public async saveFileContent (document: monaco.Uri, content: string, languageClient: LanguageClientManager): Promise<void> {
+  public async writeFile (document: monaco.Uri, content: string, languageClient: LanguageClientManager): Promise<void> {
     if (languageClient.isConnected()) {
-      await updateFile(document.toString(), content, languageClient)
+      await writeFile(document.toString(), content, languageClient)
     }
   }
 
-  public async getFileContent (resource: monaco.Uri, languageClient: LanguageClientManager): Promise<string | undefined> {
+  public async readFile (resource: monaco.Uri, languageClient: LanguageClientManager): Promise<string> {
+    return (await readFile(resource.toString(true), languageClient)).content
+  }
+
+  public async getFileStats (directory: monaco.Uri, languageClient: LanguageClientManager): Promise<StatFileResult> {
+    return (await getFileStats(directory.toString(true), languageClient))
+  }
+
+  public async listFiles (directory: monaco.Uri, languageClient: LanguageClientManager): Promise<string[]> {
     try {
-      return (await getFile(resource.toString(true), languageClient)).text
+      return (await listFiles(directory.toString(true), languageClient)).files
     } catch (error) {
-      return undefined
+      return []
     }
   }
 

src/languageClient.ts

@@ -324,7 +324,7 @@ export class LanguageClientManager implements LanguageClient {
 
     this.languageClient.registerFeature(new WillDisposeFeature(this.languageClient, this.onWillShutdownEmitter))
 
-    if (this.infrastructure.getFileContent != null) {
+    if (this.infrastructure.readFile != null) {
       this.languageClient.registerFeature(new FileSystemFeature(this.infrastructure, this))
     }