WIP

Author: Vtec234

collab-server/server.ts

@@ -19,7 +19,7 @@ const YTEXT_KEY = 'content'
 function toDiskPath(documentName: string): string {
   const file = path.normalize(documentName)
   if (!file.startsWith(projectDir)) {
-    throw new Error(`Path traversal in document name: ${documentName}`)
+    throw new Error(`Path traversal in document name: '${documentName}' escapes '${projectDir}'`)
   }
   return file
 }

src/lib/server/collabServer.ts

@@ -49,6 +49,9 @@ export class CollabServerHandle {
         await fs.rm(this.socketDir, { recursive: true, force: true })
       })
 
+      // We identify project files by absolute path
+      // so this has to match the path used in the openvscode-server bwrap.
+      const sandboxProjectDir = `/workspace/${this.project.name}/`
       const proc = spawn(
         'bwrap',
         // prettier-ignore
@@ -57,11 +60,11 @@ export class CollabServerHandle {
           '--ro-bind', getCollabServerDir(), '/workspace/.collab-server',
           '--bind', this.socketDir, '/workspace/.collab-sockets',
           // Mount project files as writable for the collaboration server.
-          '--bind', this.projectDir, '/workspace/project',
+          '--bind', this.projectDir, sandboxProjectDir,
           '/usr/bin/node',
           '/workspace/.collab-server/server.ts',
           `/workspace/.collab-sockets/${COLLAB_SOCKET_FILENAME}`,
-          '/workspace/project',
+          sandboxProjectDir,
         ],
         { stdio: 'inherit' },
       )

vscode-workbench/src/extension.ts

@@ -1,10 +1,9 @@
-import { HocuspocusProviderWebsocket } from '@hocuspocus/provider'
+import { HocuspocusProvider, HocuspocusProviderWebsocket } from '@hocuspocus/provider'
 import fs from 'node:fs/promises'
 import vs from 'vscode'
 import WebSocket from 'ws'
 import { WorkbenchFileSystemProvider } from './fsProvider'
 import { BWRAP_COLLAB_SOCK_PATH, BWRAP_WORKSPACE_FILE_PATH, WORKBENCH_URI_SCHEME } from './util'
-import { registerYjsBindings } from './yTextBinding'
 
 /** Ensure we are in the expected Lean Workbench environment.
  * Return `false` if we are not,
@@ -102,11 +101,15 @@ export async function activate(ctx: vs.ExtensionContext) {
   const collabSock = await connectToCollabServer(ctx, log)
   if (!collabSock) return
 
-  const docs = registerYjsBindings(ctx, log, collabSock)
+  // const docs = registerYjsBindings(ctx, log, collabSock)
 
   const basePath = vs.workspace.workspaceFolders![0].uri.fsPath
+  const docs2 = new Map<string, HocuspocusProvider>()
   ctx.subscriptions.push(
-    vs.workspace.registerFileSystemProvider(WORKBENCH_URI_SCHEME, new WorkbenchFileSystemProvider(basePath)),
+    vs.workspace.registerFileSystemProvider(
+      WORKBENCH_URI_SCHEME,
+      new WorkbenchFileSystemProvider(basePath, docs2, collabSock, log),
+    ),
   )
   log.debug('Extension activated')
 }

vscode-workbench/src/fsProvider.ts

@@ -1,3 +1,4 @@
+import { HocuspocusProvider, HocuspocusProviderWebsocket } from '@hocuspocus/provider'
 import path from 'node:path'
 import vs from 'vscode'
 
@@ -9,10 +10,19 @@ export class WorkbenchFileSystemProvider implements vs.FileSystemProvider {
   constructor(
     /** Base path of the project on disk. */
     readonly basePath: string,
+    /** Absolute path to file ↦ Yjs connection for that file */
+    // TODO: a wrapper on hocuspocusprovider with a promise for synced
+    // then in readFile, lazily create one of these,
+    // wait for initial sync,
+    // then return the contents.
+    private readonly docs: Map<string, HocuspocusProvider>,
+    readonly collabSock: HocuspocusProviderWebsocket,
+    private readonly log: vs.LogOutputChannel,
   ) {}
 
-  /** Convert a `wrkbnch:` URI to a `file:` URI. */
-  private toDiskUri(uri: vs.Uri): vs.Uri {
+  /** Convert a `wrkbnch:` URI to a `file:` URI,
+   * ensuring that it is accessible. */
+  private checkedToFileUri(uri: vs.Uri): vs.Uri {
     const filePath = path.normalize(uri.fsPath)
     if (!`${filePath}/`.startsWith(this.basePath)) {
       throw vs.FileSystemError.NoPermissions(uri)
@@ -22,26 +32,52 @@ export class WorkbenchFileSystemProvider implements vs.FileSystemProvider {
 
   // Operations that touch single files go through collab-server
 
+  // TODO: move to DocManager
+  async ensureHpDoc(path: string): Promise<HocuspocusProvider> {
+    let doc = this.docs.get(path)
+    // TODO should wait on doc.synced; same deal as `EditorSessionManager`
+    if (doc) return doc
+    return new Promise((resolve, reject) => {
+      doc = new HocuspocusProvider({
+        websocketProvider: this.collabSock,
+        name: path,
+        onSynced: data => {
+          console.log(`[HocuspocusProvider] '${path}' synced ${String(data.state)}`)
+          // this.log.trace(`[HocuspocusProvider] '${path}' synced ${String(data.state)}`)
+          resolve(doc!)
+        },
+      })
+      setTimeout(() => {
+        reject(new Error('timeout waiting for HocuspocusProvider'))
+      }, 3_000)
+      this.docs.set(path, doc)
+      doc.attach()
+    })
+  }
+
   watch(): vs.Disposable {
     throw new Error('TODO watch')
   }
 
   async stat(uri: vs.Uri): Promise<vs.FileStat> {
     // TODO: stat from Yjs
-    return vs.workspace.fs.stat(this.toDiskUri(uri))
+    return vs.workspace.fs.stat(this.checkedToFileUri(uri))
   }
 
   async readFile(uri: vs.Uri): Promise<Uint8Array> {
-    // TODO: prefer reads from Yjs
-    return vs.workspace.fs.readFile(this.toDiskUri(uri))
+    // TODO: only read from Yjs; ignore fs.
+    console.log(`reading file ${JSON.stringify(uri)}`)
+    const doc = await this.ensureHpDoc(this.checkedToFileUri(uri).fsPath)
+    console.log(`read file ${JSON.stringify(uri)} from Yjs`)
+    return vs.workspace.fs.readFile(this.checkedToFileUri(uri))
   }
 
   async writeFile(
     uri: vs.Uri,
     content: Uint8Array,
     options: { readonly create: boolean; readonly overwrite: boolean },
   ): Promise<void> {
-    const existed = await this.stat(this.toDiskUri(uri)).then(
+    const existed = await this.stat(this.checkedToFileUri(uri)).then(
       () => true,
       () => false,
     )
@@ -54,21 +90,21 @@ export class WorkbenchFileSystemProvider implements vs.FileSystemProvider {
   // Filesystem operations go through the filesystem
 
   async readDirectory(uri: vs.Uri): Promise<[string, vs.FileType][]> {
-    return vs.workspace.fs.readDirectory(this.toDiskUri(uri))
+    return vs.workspace.fs.readDirectory(this.checkedToFileUri(uri))
   }
 
   async createDirectory(uri: vs.Uri): Promise<void> {
-    await vs.workspace.fs.createDirectory(this.toDiskUri(uri))
+    await vs.workspace.fs.createDirectory(this.checkedToFileUri(uri))
     this.onDidChangeFileEmitter.fire([{ type: vs.FileChangeType.Created, uri }])
   }
 
   async delete(uri: vs.Uri, options: { readonly recursive: boolean }): Promise<void> {
-    await vs.workspace.fs.delete(this.toDiskUri(uri), options)
+    await vs.workspace.fs.delete(this.checkedToFileUri(uri), options)
     this.onDidChangeFileEmitter.fire([{ type: vs.FileChangeType.Deleted, uri }])
   }
 
   async rename(oldUri: vs.Uri, newUri: vs.Uri, options: { readonly overwrite: boolean }): Promise<void> {
-    await vs.workspace.fs.rename(this.toDiskUri(oldUri), this.toDiskUri(newUri), options)
+    await vs.workspace.fs.rename(this.checkedToFileUri(oldUri), this.checkedToFileUri(newUri), options)
     this.onDidChangeFileEmitter.fire([
       { type: vs.FileChangeType.Deleted, uri: oldUri },
       { type: vs.FileChangeType.Created, uri: newUri },

vscode-workbench/src/yTextBinding.ts

@@ -13,6 +13,7 @@ export function registerYjsBindings(
   const docs = new Map<string, DocEntry>()
 
   const onDidOpenTextDocument = (doc: vs.TextDocument) => {
+    console.log(`did open ${JSON.stringify(doc.uri)}`)
     if (doc.uri.scheme !== WORKBENCH_URI_SCHEME) return
     const name = doc.uri.fsPath
     if (docs.has(name)) return
@@ -69,6 +70,7 @@ export class YTextBinding implements vs.Disposable {
   private ytext: Y.Text
   /** Used to prevent `applyEdit` bounceback when applying remote changes;
    * when set, local `onDidChangeTextDocument` events are ignored. */
+  // FIXME: try hard to hack through vscode and tag edit events. Would be much simpler.
   private applyingRemote = false
   private initialSyncDone = false
   /** Used to linearize async operations that might otherwise interleave. */
@@ -78,10 +80,10 @@ export class YTextBinding implements vs.Disposable {
 
   constructor(
     readonly doc: vs.TextDocument,
-    readonly hs: HocuspocusProvider,
+    readonly hp: HocuspocusProvider,
     private readonly log: vs.LogOutputChannel,
   ) {
-    this.ytext = hs.document.getText(YTEXT_KEY)
+    this.ytext = hp.document.getText(YTEXT_KEY)
 
     const observer = (event: Y.YTextEvent, transaction: Y.Transaction) => {
       // First check prevents bounceback (https://beta.yjs.dev/docs/api/transactions/#the-origin-concept).
@@ -97,17 +99,17 @@ export class YTextBinding implements vs.Disposable {
       },
     })
 
-    if (hs.synced) {
-      this.enqueue(() => this.initialSync())
+    if (hp.synced) {
+      this.enqueue(() => this.onInitialSync())
     } else {
       const onSynced = () => {
-        hs.off('synced', onSynced)
-        this.enqueue(() => this.initialSync())
+        hp.off('synced', onSynced)
+        this.enqueue(() => this.onInitialSync())
       }
-      hs.on('synced', onSynced)
+      hp.on('synced', onSynced)
       this.disposables.push({
         dispose: () => {
-          hs.off('synced', onSynced)
+          hp.off('synced', onSynced)
         },
       })
     }
@@ -123,10 +125,13 @@ export class YTextBinding implements vs.Disposable {
   }
 
   onLocalChange(e: vs.TextDocumentChangeEvent): void {
+    // BUG 1: local edits made before onInitialSync are lost.
+    // BUG 2: local edits that arrive while `applyingRemote` is set are lost.
+    //        would also linearizing `onLocalChange` help?
     if (this.applyingRemote || !this.initialSyncDone) return
     if (e.document !== this.doc) return
     if (e.contentChanges.length === 0) return
-    this.hs.document.transact(() => {
+    this.hp.document.transact(() => {
       // VSCode sorts `contentChanges` in reverse offset order
       // so they can be applied sequentially without offset adjustment.
       for (const ch of e.contentChanges) {
@@ -136,11 +141,11 @@ export class YTextBinding implements vs.Disposable {
     }, this)
   }
 
-  /** Reconcile the editor with `Y.Text` once the initial sync has completed.
+  /** Overwrite buffer state with remote `Y.Text` once initial sync has completed.
    * Order matters: read `ytext` and set `initialSyncDone = true` synchronously
    * so that any remote delta arriving during the subsequent `applyEdit` is queued (not dropped)
    * and later applied on top of the new editor content. */
-  private async initialSync(): Promise<void> {
+  private async onInitialSync(): Promise<void> {
     const ytextStr = this.ytext.toString()
     this.initialSyncDone = true
     if (ytextStr === this.doc.getText()) return