Add FileSystemProvider, New File command, and workspace folder mount

- Add WebDavFileSystemProvider with caching, stat/readDirectory/readFile/
  writeFile/createDirectory/delete operations against WebDAV
- Root path handling returns synthetic directory listing of the 9 well-known
  B2C Commerce roots (avoids PROPFIND on "/")
- Tree provider delegates to FS provider instead of calling WebDAV directly;
  root nodes use standard folder icons via resourceUri
- New File command: prompts for filename, creates empty file, opens in editor
- Mount/Unmount Workspace commands: add/remove b2c-webdav:/ as a VS Code
  workspace folder for native Explorer integration
- Context key b2c-dx.webdav.mounted tracks mount state for menu visibility
- Download command available in native Explorer context menu for b2c-webdav files

Author: clavery

packages/b2c-vs-extension/package.json

@@ -19,6 +19,7 @@
   },
   "activationEvents": [
     "onView:b2cWebdavExplorer",
+    "onFileSystem:b2c-webdav",
     "onCommand:b2c-dx.openUI",
     "onCommand:b2c-dx.handleStorefrontNextCartridge",
     "onCommand:b2c-dx.promptAgent",
@@ -119,6 +120,24 @@
         "title": "Open File",
         "icon": "$(go-to-file)",
         "category": "B2C DX"
+      },
+      {
+        "command": "b2c-dx.webdav.newFile",
+        "title": "New File",
+        "icon": "$(new-file)",
+        "category": "B2C DX"
+      },
+      {
+        "command": "b2c-dx.webdav.mountWorkspace",
+        "title": "Open as Workspace Folder",
+        "icon": "$(root-folder-opened)",
+        "category": "B2C DX"
+      },
+      {
+        "command": "b2c-dx.webdav.unmountWorkspace",
+        "title": "Remove Workspace Folder",
+        "icon": "$(root-folder)",
+        "category": "B2C DX"
       }
     ],
     "menus": {
@@ -127,9 +146,24 @@
           "command": "b2c-dx.webdav.refresh",
           "when": "view == b2cWebdavExplorer",
           "group": "navigation"
+        },
+        {
+          "command": "b2c-dx.webdav.mountWorkspace",
+          "when": "view == b2cWebdavExplorer && !b2c-dx.webdav.mounted",
+          "group": "navigation"
+        },
+        {
+          "command": "b2c-dx.webdav.unmountWorkspace",
+          "when": "view == b2cWebdavExplorer && b2c-dx.webdav.mounted",
+          "group": "navigation"
         }
       ],
       "view/item/context": [
+        {
+          "command": "b2c-dx.webdav.newFile",
+          "when": "view == b2cWebdavExplorer && viewItem =~ /^(root|directory)$/",
+          "group": "1_modification@0"
+        },
         {
           "command": "b2c-dx.webdav.newFolder",
           "when": "view == b2cWebdavExplorer && viewItem =~ /^(root|directory)$/",
@@ -155,6 +189,13 @@
           "when": "view == b2cWebdavExplorer && viewItem =~ /^(directory|file)$/",
           "group": "2_destructive@1"
         }
+      ],
+      "explorer/context": [
+        {
+          "command": "b2c-dx.webdav.download",
+          "when": "resourceScheme == b2c-webdav && !explorerResourceIsFolder",
+          "group": "navigation"
+        }
       ]
     }
   },

packages/b2c-vs-extension/src/webdav-tree/index.ts

@@ -5,19 +5,35 @@
  */
 import * as vscode from 'vscode';
 import {WebDavConfigProvider} from './webdav-config.js';
+import {WEBDAV_SCHEME, WebDavFileSystemProvider} from './webdav-fs-provider.js';
 import {WebDavTreeDataProvider} from './webdav-tree-provider.js';
 import {registerWebDavCommands} from './webdav-commands.js';
 
+function syncMountedContext(): void {
+  const mounted = (vscode.workspace.workspaceFolders ?? []).some((f) => f.uri.scheme === WEBDAV_SCHEME);
+  vscode.commands.executeCommand('setContext', 'b2c-dx.webdav.mounted', mounted);
+}
+
 export function registerWebDavTree(context: vscode.ExtensionContext): void {
   const configProvider = new WebDavConfigProvider();
-  const treeProvider = new WebDavTreeDataProvider(configProvider);
+  const fsProvider = new WebDavFileSystemProvider(configProvider);
+
+  const fsRegistration = vscode.workspace.registerFileSystemProvider(WEBDAV_SCHEME, fsProvider, {
+    isCaseSensitive: true,
+  });
+
+  const treeProvider = new WebDavTreeDataProvider(configProvider, fsProvider);
 
   const treeView = vscode.window.createTreeView('b2cWebdavExplorer', {
     treeDataProvider: treeProvider,
     showCollapseAll: true,
   });
 
-  const commandDisposables = registerWebDavCommands(context, configProvider, treeProvider);
+  const commandDisposables = registerWebDavCommands(context, configProvider, treeProvider, fsProvider);
+
+  // Sync the mounted context key on activation and when workspace folders change
+  syncMountedContext();
+  const folderWatcher = vscode.workspace.onDidChangeWorkspaceFolders(() => syncMountedContext());
 
-  context.subscriptions.push(treeView, ...commandDisposables);
+  context.subscriptions.push(fsRegistration, treeView, folderWatcher, ...commandDisposables);
 }

packages/b2c-vs-extension/src/webdav-tree/webdav-commands.ts

@@ -7,25 +7,23 @@ import * as fs from 'fs';
 import * as path from 'path';
 import * as vscode from 'vscode';
 import type {WebDavConfigProvider} from './webdav-config.js';
+import {type WebDavFileSystemProvider, WEBDAV_SCHEME, webdavPathToUri} from './webdav-fs-provider.js';
 import type {WebDavTreeDataProvider, WebDavTreeItem} from './webdav-tree-provider.js';
 
 export function registerWebDavCommands(
-  context: vscode.ExtensionContext,
+  _context: vscode.ExtensionContext,
   configProvider: WebDavConfigProvider,
   treeProvider: WebDavTreeDataProvider,
+  fsProvider: WebDavFileSystemProvider,
 ): vscode.Disposable[] {
   const refresh = vscode.commands.registerCommand('b2c-dx.webdav.refresh', () => {
+    fsProvider.clearCache();
     configProvider.reset();
     treeProvider.refresh();
   });
 
   const newFolder = vscode.commands.registerCommand('b2c-dx.webdav.newFolder', async (node: WebDavTreeItem) => {
     if (!node) return;
-    const instance = configProvider.getInstance();
-    if (!instance) {
-      vscode.window.showErrorMessage('WebDAV: No B2C instance configured.');
-      return;
-    }
 
     const name = await vscode.window.showInputBox({
       title: 'New Folder',
@@ -45,8 +43,7 @@ export function registerWebDavCommands(
       {location: vscode.ProgressLocation.Notification, title: `Creating folder ${name.trim()}...`},
       async () => {
         try {
-          await instance.webdav.mkcol(fullPath);
-          treeProvider.refreshNode(node);
+          await fsProvider.createDirectory(webdavPathToUri(fullPath));
         } catch (err) {
           const message = err instanceof Error ? err.message : String(err);
           vscode.window.showErrorMessage(`WebDAV: Failed to create folder: ${message}`);
@@ -57,11 +54,6 @@ export function registerWebDavCommands(
 
   const uploadFile = vscode.commands.registerCommand('b2c-dx.webdav.uploadFile', async (node: WebDavTreeItem) => {
     if (!node) return;
-    const instance = configProvider.getInstance();
-    if (!instance) {
-      vscode.window.showErrorMessage('WebDAV: No B2C instance configured.');
-      return;
-    }
 
     const uris = await vscode.window.showOpenDialog({
       title: 'Select file to upload',
@@ -80,19 +72,10 @@ export function registerWebDavCommands(
       async () => {
         try {
           const content = fs.readFileSync(uri.fsPath);
-          const ext = path.extname(fileName).toLowerCase();
-          const mime: Record<string, string> = {
-            '.json': 'application/json',
-            '.xml': 'application/xml',
-            '.zip': 'application/zip',
-            '.js': 'application/javascript',
-            '.ts': 'application/typescript',
-            '.html': 'text/html',
-            '.css': 'text/css',
-            '.txt': 'text/plain',
-          };
-          await instance.webdav.put(fullPath, content, mime[ext]);
-          treeProvider.refreshNode(node);
+          await fsProvider.writeFile(webdavPathToUri(fullPath), new Uint8Array(content), {
+            create: true,
+            overwrite: true,
+          });
         } catch (err) {
           const message = err instanceof Error ? err.message : String(err);
           vscode.window.showErrorMessage(`WebDAV: Upload failed: ${message}`);
@@ -103,11 +86,6 @@ export function registerWebDavCommands(
 
   const deleteItem = vscode.commands.registerCommand('b2c-dx.webdav.delete', async (node: WebDavTreeItem) => {
     if (!node) return;
-    const instance = configProvider.getInstance();
-    if (!instance) {
-      vscode.window.showErrorMessage('WebDAV: No B2C instance configured.');
-      return;
-    }
 
     const detail = node.isCollection
       ? 'This directory and its contents will be deleted.'
@@ -124,10 +102,7 @@ export function registerWebDavCommands(
       {location: vscode.ProgressLocation.Notification, title: `Deleting ${node.fileName}...`},
       async () => {
         try {
-          await instance.webdav.delete(node.webdavPath);
-          // Refresh parent by refreshing the whole tree — the parent node
-          // is not directly available from the child.
-          treeProvider.refresh();
+          await fsProvider.delete(webdavPathToUri(node.webdavPath));
         } catch (err) {
           const message = err instanceof Error ? err.message : String(err);
           vscode.window.showErrorMessage(`WebDAV: Delete failed: ${message}`);
@@ -138,11 +113,6 @@ export function registerWebDavCommands(
 
   const download = vscode.commands.registerCommand('b2c-dx.webdav.download', async (node: WebDavTreeItem) => {
     if (!node) return;
-    const instance = configProvider.getInstance();
-    if (!instance) {
-      vscode.window.showErrorMessage('WebDAV: No B2C instance configured.');
-      return;
-    }
 
     const defaultUri = vscode.workspace.workspaceFolders?.[0]?.uri
       ? vscode.Uri.joinPath(vscode.workspace.workspaceFolders[0].uri, node.fileName)
@@ -157,8 +127,8 @@ export function registerWebDavCommands(
       {location: vscode.ProgressLocation.Notification, title: `Downloading ${node.fileName}...`},
       async () => {
         try {
-          const buffer = await instance.webdav.get(node.webdavPath);
-          await vscode.workspace.fs.writeFile(saveUri, new Uint8Array(buffer));
+          const content = await fsProvider.readFile(webdavPathToUri(node.webdavPath));
+          await vscode.workspace.fs.writeFile(saveUri, content);
           vscode.window.showInformationMessage(`Downloaded to ${saveUri.fsPath}`);
         } catch (err) {
           const message = err instanceof Error ? err.message : String(err);
@@ -170,32 +140,56 @@ export function registerWebDavCommands(
 
   const openFile = vscode.commands.registerCommand('b2c-dx.webdav.openFile', async (node: WebDavTreeItem) => {
     if (!node) return;
-    const instance = configProvider.getInstance();
-    if (!instance) {
-      vscode.window.showErrorMessage('WebDAV: No B2C instance configured.');
-      return;
-    }
+    const uri = webdavPathToUri(node.webdavPath);
+    await vscode.commands.executeCommand('vscode.open', uri);
+  });
 
-    const previewDir = vscode.Uri.joinPath(context.globalStorageUri, 'webdav-preview');
-    const tempFileUri = vscode.Uri.joinPath(previewDir, node.webdavPath);
+  const newFile = vscode.commands.registerCommand('b2c-dx.webdav.newFile', async (node: WebDavTreeItem) => {
+    if (!node) return;
 
+    const name = await vscode.window.showInputBox({
+      title: 'New File',
+      prompt: `Create file under ${node.webdavPath}`,
+      placeHolder: 'File name',
+      validateInput: (value: string) => {
+        const trimmed = value.trim();
+        if (!trimmed) return 'Enter a file name';
+        if (/[\\/:*?"<>|]/.test(trimmed)) return 'Name cannot contain \\ / : * ? " < > |';
+        return null;
+      },
+    });
+    if (!name) return;
+
+    const fullPath = `${node.webdavPath}/${name.trim()}`;
+    const uri = webdavPathToUri(fullPath);
     await vscode.window.withProgress(
-      {location: vscode.ProgressLocation.Notification, title: `Opening ${node.fileName}...`},
+      {location: vscode.ProgressLocation.Notification, title: `Creating file ${name.trim()}...`},
       async () => {
         try {
-          const buffer = await instance.webdav.get(node.webdavPath);
-          // Ensure parent directories exist
-          const parentDir = vscode.Uri.joinPath(tempFileUri, '..');
-          await vscode.workspace.fs.createDirectory(parentDir);
-          await vscode.workspace.fs.writeFile(tempFileUri, new Uint8Array(buffer));
-          await vscode.commands.executeCommand('vscode.open', tempFileUri);
+          await fsProvider.writeFile(uri, new Uint8Array(0), {create: true, overwrite: false});
+          await vscode.commands.executeCommand('vscode.open', uri);
         } catch (err) {
           const message = err instanceof Error ? err.message : String(err);
-          vscode.window.showErrorMessage(`WebDAV: Failed to open file: ${message}`);
+          vscode.window.showErrorMessage(`WebDAV: Failed to create file: ${message}`);
         }
       },
     );
   });
 
-  return [refresh, newFolder, uploadFile, deleteItem, download, openFile];
+  const mountWorkspace = vscode.commands.registerCommand('b2c-dx.webdav.mountWorkspace', () => {
+    vscode.workspace.updateWorkspaceFolders(vscode.workspace.workspaceFolders?.length ?? 0, 0, {
+      uri: vscode.Uri.parse(`${WEBDAV_SCHEME}:/`),
+      name: 'B2C Commerce WebDAV',
+    });
+  });
+
+  const unmountWorkspace = vscode.commands.registerCommand('b2c-dx.webdav.unmountWorkspace', () => {
+    const folders = vscode.workspace.workspaceFolders ?? [];
+    const idx = folders.findIndex((f) => f.uri.scheme === WEBDAV_SCHEME);
+    if (idx >= 0) {
+      vscode.workspace.updateWorkspaceFolders(idx, 1);
+    }
+  });
+
+  return [refresh, newFolder, newFile, uploadFile, deleteItem, download, openFile, mountWorkspace, unmountWorkspace];
 }