feat: add workspace name support for WebDAV connections and improve directory resource handling

Author: erdalkaraca

packages/extension-webdav/src/webdav-client.ts

@@ -2,6 +2,8 @@ export interface WebDAVConnectionInfo {
     url: string;
     username?: string;
     password?: string;
+    /** Workspace root label (composite path prefix); defaults to webdav1, webdav2, … */
+    name?: string;
 }
 
 export interface WebDAVResource {

packages/extension-webdav/src/webdav-extension.ts

@@ -33,27 +33,41 @@ import { LyraWebDAVConnect } from "./webdav-connect";
 // Import commands (registers themselves)
 import './webdav-commands';
 
+async function getNextWebdavWorkspaceName(): Promise<string> {
+    const folders = await workspaceService.getFolders();
+    const used = new Set(folders.filter((f) => f.type === 'webdav').map((f) => f.name));
+    let n = 1;
+    while (used.has(`webdav${n}`)) {
+        n += 1;
+    }
+    return `webdav${n}`;
+}
+
 // Register WebDAV as a workspace contribution
 workspaceService.registerContribution({
     type: 'webdav',
     name: 'webdav',
-    
+
     canHandle(input: any): boolean {
         // Accept any connection info with a URL (credentials are optional for public/shared folders)
         return input && typeof input === 'object' && 'url' in input && typeof input.url === 'string';
     },
-    
+
     async connect(input: WebDAVConnectionInfo) {
+        const name =
+            typeof input.name === 'string' && input.name.trim().length > 0
+                ? input.name.trim()
+                : await getNextWebdavWorkspaceName();
         const client = new WebDAVClient(input);
         const rootResource: WebDAVResource = {
             href: input.url,
             displayName: extractWorkspaceNameFromUrl(input.url),
             isDirectory: true
         };
-        return new WebDAVDirectoryResource(client, rootResource, undefined, input);
+        return new WebDAVDirectoryResource(client, rootResource, undefined, { ...input, name });
     },
-    
-    async restore(data: WebDAVConnectionInfo) {
+
+    async restore(data: WebDAVConnectionInfo & { name?: string }) {
         if (!data || !data.url) {
             return undefined;
         }
@@ -64,20 +78,24 @@ workspaceService.registerContribution({
                 username: data.username,
                 password: data.password ? decodePassword(data.password) : undefined
             };
+            const name =
+                typeof data.name === 'string' && data.name.trim().length > 0
+                    ? data.name.trim()
+                    : await getNextWebdavWorkspaceName();
 
             const client = new WebDAVClient(restored);
             const rootResource: WebDAVResource = {
                 href: data.url,
                 displayName: extractWorkspaceNameFromUrl(data.url),
                 isDirectory: true
             };
-            return new WebDAVDirectoryResource(client, rootResource, undefined, restored);
+            return new WebDAVDirectoryResource(client, rootResource, undefined, { ...restored, name });
         } catch (error) {
             logger.error('Failed to restore WebDAV workspace:', error);
             return undefined;
         }
     },
-    
+
     async persist(workspace) {
         if (workspace instanceof WebDAVDirectoryResource) {
             const connectionInfo = workspace.getConnectionInfo();
@@ -87,6 +105,7 @@ workspaceService.registerContribution({
 
             return {
                 url: connectionInfo.url,
+                name: workspace.getName(),
                 ...(connectionInfo.username !== undefined ? { username: connectionInfo.username } : {}),
                 ...(connectionInfo.password !== undefined ? { password: encodePassword(connectionInfo.password) } : {})
             };

packages/extension-webdav/src/webdav-filesys.ts

@@ -95,16 +95,26 @@ export class WebDAVDirectoryResource extends Directory {
     private parent?: Directory;
     private children?: Map<string, Resource>;
     private connectionInfo?: WebDAVConnectionInfo;
+    /** Workspace root label only; nested dirs use {@link WebDAVResource.displayName}. */
+    private rootFolderDisplayName?: string;
 
     constructor(client: WebDAVClient, resource: WebDAVResource, parent?: Directory, connectionInfo?: WebDAVConnectionInfo) {
         super();
         this.client = client;
         this.resource = resource;
         this.parent = parent;
         this.connectionInfo = connectionInfo;
+        if (!parent) {
+            const n = connectionInfo?.name?.trim();
+            this.rootFolderDisplayName =
+                n && n.length > 0 ? n : extractLeafNameFromUrl(connectionInfo?.url ?? resource.href);
+        }
     }
 
     getName(): string {
+        if (this.rootFolderDisplayName !== undefined) {
+            return this.rootFolderDisplayName;
+        }
         return this.resource.displayName;
     }
 
@@ -219,18 +229,28 @@ export class WebDAVDirectoryResource extends Directory {
     }
 
     async rename(newName: string): Promise<void> {
-        if (this.getName() === newName) {
+        const trimmed = String(newName ?? '').trim();
+        if (!trimmed || this.getName() === trimmed) {
+            return;
+        }
+
+        if (!this.parent) {
+            this.rootFolderDisplayName = trimmed;
+            if (this.connectionInfo) {
+                this.connectionInfo = { ...this.connectionInfo, name: trimmed };
+            }
+            await workspaceService.updateFolderName(this, trimmed);
             return;
         }
 
         const pathParts = this.resource.href.split('/').filter(Boolean);
-        pathParts[pathParts.length - 1] = newName;
+        pathParts[pathParts.length - 1] = trimmed;
         const newPath = '/' + pathParts.join('/') + '/';
-        
+
         await this.client.moveResource(this.resource.href, newPath);
         this.resource.href = newPath;
-        this.resource.displayName = newName;
-        
+        this.resource.displayName = trimmed;
+
         publish(TOPIC_WORKSPACE_CHANGED, workspaceService.getWorkspaceSync() ?? this.getWorkspace());
     }
 
@@ -263,3 +283,13 @@ export class WebDAVDirectoryResource extends Directory {
     }
 }
 
+function extractLeafNameFromUrl(url: string): string {
+    try {
+        const urlObj = new URL(url);
+        const pathParts = urlObj.pathname.split('/').filter(Boolean);
+        return pathParts[pathParts.length - 1] || 'workspace';
+    } catch {
+        return 'workspace';
+    }
+}
+