Add create file support to WSFS explorer

Author: misha-db

packages/databricks-vscode/package.json

@@ -196,6 +196,20 @@
                 "enablement": "databricks.context.activated && databricks.context.loggedIn && !databricks.context.remoteMode",
                 "category": "Databricks"
             },
+            {
+                "command": "databricks.wsfs.createNewFile",
+                "title": "Create File",
+                "icon": "$(new-file)",
+                "enablement": "databricks.context.activated && databricks.context.loggedIn && !databricks.context.remoteMode",
+                "category": "Databricks"
+            },
+            {
+                "command": "databricks.wsfs.createNewFile.toolbar",
+                "title": "Create File",
+                "icon": "$(new-file)",
+                "enablement": "databricks.context.activated && databricks.context.loggedIn && !databricks.context.remoteMode",
+                "category": "Databricks"
+            },
             {
                 "command": "databricks.wsfs.openInBrowser",
                 "title": "Open in Browser",
@@ -726,6 +740,11 @@
                     "when": "view == workspaceFsView",
                     "group": "navigation@1"
                 },
+                {
+                    "command": "databricks.wsfs.createNewFile.toolbar",
+                    "when": "view == workspaceFsView",
+                    "group": "navigation@1"
+                },
                 {
                     "command": "databricks.unityCatalog.filter",
                     "when": "view == unityCatalogView",
@@ -803,10 +822,15 @@
                     "group": "wsfs_mut@0"
                 },
                 {
-                    "command": "databricks.wsfs.uploadFile",
+                    "command": "databricks.wsfs.createNewFile",
                     "when": "view == workspaceFsView && (viewItem == wsfs.directory || viewItem == wsfs.repo)",
                     "group": "wsfs_mut@1"
                 },
+                {
+                    "command": "databricks.wsfs.uploadFile",
+                    "when": "view == workspaceFsView && (viewItem == wsfs.directory || viewItem == wsfs.repo)",
+                    "group": "wsfs_mut@2"
+                },
                 {
                     "command": "databricks.wsfs.downloadFile",
                     "when": "view == workspaceFsView && (viewItem == wsfs.file || viewItem == wsfs.notebook)",

packages/databricks-vscode/src/extension.ts

@@ -429,6 +429,16 @@ export async function activate(
             workspaceFsCommands.createFolderFromToolbar,
             workspaceFsCommands
         ),
+        telemetry.registerCommand(
+            "databricks.wsfs.createNewFile",
+            workspaceFsCommands.createFile,
+            workspaceFsCommands
+        ),
+        telemetry.registerCommand(
+            "databricks.wsfs.createNewFile.toolbar",
+            workspaceFsCommands.createFileFromToolbar,
+            workspaceFsCommands
+        ),
         telemetry.registerCommand(
             "databricks.wsfs.openInBrowser",
             workspaceFsCommands.openInBrowser,

packages/databricks-vscode/src/workspace-fs/WorkspaceFsCommands.test.ts

@@ -126,6 +126,59 @@ describe("WorkspaceFsCommands – target folder resolution", () => {
         });
     });
 
+    // createFile mirrors createFolder's target resolution but, like upload,
+    // checks workspaceClient before reaching getValidRoot.
+    describe("createFile (context menu)", () => {
+        beforeEach(() => {
+            when(mockConnectionManager.workspaceClient).thenReturn({} as any);
+        });
+
+        it("no element → targets root", async () => {
+            await commands.createFile(undefined);
+            assert.strictEqual(capturedRootPath, ROOT_PATH);
+        });
+
+        it("element=A → targets A", async () => {
+            await commands.createFile(entityA);
+            assert.strictEqual(capturedRootPath, entityA.path);
+        });
+
+        it("element=B while A is selected → targets B", async () => {
+            fakeTreeView.simulateSelect(entityA);
+            await commands.createFile(entityB);
+            assert.strictEqual(capturedRootPath, entityB.path);
+        });
+    });
+
+    describe("createFileFromToolbar (toolbar)", () => {
+        beforeEach(() => {
+            when(mockConnectionManager.workspaceClient).thenReturn({} as any);
+        });
+
+        it("nothing selected → targets root", async () => {
+            await commands.createFileFromToolbar(undefined);
+            assert.strictEqual(capturedRootPath, ROOT_PATH);
+        });
+
+        it("A selected, toolbar clicked → targets A", async () => {
+            fakeTreeView.simulateSelect(entityA);
+            await commands.createFileFromToolbar(entityA);
+            assert.strictEqual(capturedRootPath, entityA.path);
+        });
+
+        it("selection cleared before toolbar click → targets root", async () => {
+            fakeTreeView.simulateSelect(entityA);
+            fakeTreeView.simulateSelect(undefined);
+            await commands.createFileFromToolbar(undefined);
+            assert.strictEqual(capturedRootPath, ROOT_PATH);
+        });
+
+        it("element passed but nothing selected (edge case) → targets root", async () => {
+            await commands.createFileFromToolbar(entityA);
+            assert.strictEqual(capturedRootPath, ROOT_PATH);
+        });
+    });
+
     describe("uploadFile (context menu)", () => {
         // doUploadFile checks workspaceClient before reaching getValidRoot;
         // provide a non-null client so root-path resolution is exercised.

packages/databricks-vscode/src/workspace-fs/WorkspaceFsCommands.ts

@@ -141,6 +141,91 @@ export class WorkspaceFsCommands implements Disposable {
         return created;
     }
 
+    @withLogContext(Loggers.Extension)
+    async createFile(element?: WorkspaceFsEntity, @context ctx?: Context) {
+        const rootPath =
+            element?.path ??
+            this.connectionManager.databricksWorkspace?.currentFsRoot.path;
+        return this.doCreateFile(rootPath, ctx);
+    }
+
+    @withLogContext(Loggers.Extension)
+    async createFileFromToolbar(
+        element?: WorkspaceFsEntity,
+        @context ctx?: Context
+    ) {
+        const activeElement = this.resolveTargetElementForToolbar(element);
+        const rootPath =
+            activeElement?.path ??
+            this.connectionManager.databricksWorkspace?.currentFsRoot.path;
+        return this.doCreateFile(rootPath, ctx);
+    }
+
+    @withLogContext(Loggers.Extension)
+    private async doCreateFile(
+        rootPath: string | undefined,
+        @context ctx?: Context
+    ) {
+        const client = this.connectionManager.workspaceClient;
+        if (!client) {
+            window.showErrorMessage("Please login first to create a file");
+            return;
+        }
+
+        const root = await this.getValidRoot(rootPath, ctx);
+        if (!root) {
+            return;
+        }
+
+        const inputName = await createDirWizard(
+            this.workspaceFolderManager.activeProjectUri,
+            "File Name",
+            root
+        );
+
+        if (inputName === undefined) {
+            return;
+        }
+
+        const existing = await WorkspaceFsEntity.fromPath(
+            client,
+            `${root.path}/${inputName}`
+        );
+        if (existing) {
+            const answer = await window.showWarningMessage(
+                `"${inputName}" already exists in the workspace. Overwrite it?`,
+                {modal: true},
+                "Overwrite"
+            );
+            if (answer !== "Overwrite") {
+                return;
+            }
+        }
+
+        try {
+            await root.createFile(inputName, "", true);
+        } catch (e: unknown) {
+            const msg = e instanceof Error ? e.message : String(e);
+            window.showErrorMessage(`Failed to create "${inputName}": ${msg}`);
+            return;
+        }
+
+        this.workspaceFsDataProvider.refresh();
+        const uri = Uri.from({
+            scheme: WorkspaceFsFileSystemProvider.scheme,
+            path: `${root.path}/${inputName}`,
+        });
+        this.fsp.notifyCreated(uri);
+
+        try {
+            await window.showTextDocument(
+                await workspace.openTextDocument(uri)
+            );
+        } catch (e: unknown) {
+            ctx?.logger?.error(`Can't open ${inputName} after creation`, e);
+        }
+    }
+
     private async createRepo(repoPath: string) {
         const wsClient = this.connectionManager.workspaceClient;
         if (!wsClient) {