[MDiff] Implement read-only file support in metadata diff (#1404)

priyanshu92 · claude · web-flow · commit e6c300056223 · 2025-12-30T15:33:45.000+05:30
* [MDiff] Implement read-only file support in metadata diff ✨ Added ReadOnlyContentProvider to handle read-only files. 🔗 Integrated read-only URIs in metadata diff handlers. 🧪 Added tests for ReadOnlyContentProvider functionality. 📝 Updated existing tests to verify read-only behavior. -Priyanshu * [MDiff] Remove unmockable fs method tests from ReadOnlyContentProvider Remove tests that attempted to stub fs.existsSync and fs.statSync, which are non-configurable properties and cannot be mocked with sinon. The remaining tests cover URI creation, singleton pattern, and write operation restrictions. 🤖 Generated with [Claude Code](https://claude.com/claude-code) Co-Authored-By: Claude Opus 4.5 <noreply@anthropic.com> --------- Co-authored-by: Claude Opus 4.5 <noreply@anthropic.com>
diff --git a/src/client/power-pages/actions-hub/ActionsHubTreeDataProvider.ts b/src/client/power-pages/actions-hub/ActionsHubTreeDataProvider.ts
@@ -46,6 +46,7 @@ import { clearMetadataDiff } from "./handlers/metadata-diff/ClearMetadataDiffHan
 import { viewAsTree, viewAsList } from "./handlers/metadata-diff/ToggleViewModeHandler";
 import { sortByName, sortByPath, sortByStatus } from "./handlers/metadata-diff/SortModeHandler";
 import { MetadataDiffDecorationProvider } from "./MetadataDiffDecorationProvider";
+import { ReadOnlyContentProvider } from "./ReadOnlyContentProvider";
 import { removeSiteComparison } from "./handlers/metadata-diff/RemoveSiteHandler";
 import { discardLocalChanges } from "./handlers/metadata-diff/DiscardLocalChangesHandler";
 import { discardFolderChanges } from "./handlers/metadata-diff/DiscardFolderChangesHandler";
@@ -382,7 +383,8 @@ export class ActionsHubTreeDataProvider implements vscode.TreeDataProvider<Actio
                 vscode.commands.registerCommand(Constants.Commands.METADATA_DIFF_EXPORT, exportMetadataDiff),
                 vscode.commands.registerCommand(Constants.Commands.METADATA_DIFF_IMPORT, importMetadataDiff),
                 vscode.commands.registerCommand(Constants.Commands.METADATA_DIFF_RESYNC, resyncMetadataDiff(this._pacTerminal, this._context)),
-                MetadataDiffDecorationProvider.getInstance().register()
+                MetadataDiffDecorationProvider.getInstance().register(),
+                ReadOnlyContentProvider.getInstance().register()
             );
         }
 
diff --git a/src/client/power-pages/actions-hub/ReadOnlyContentProvider.ts b/src/client/power-pages/actions-hub/ReadOnlyContentProvider.ts
@@ -0,0 +1,122 @@
+/*
+ * Copyright (c) Microsoft Corporation. All rights reserved.
+ * Licensed under the MIT License. See License.txt in the project root for license information.
+ */
+
+import * as vscode from "vscode";
+import * as fs from "fs";
+
+/**
+ * URI scheme for read-only remote files in metadata diff
+ */
+export const METADATA_DIFF_READONLY_SCHEME = "pp-metadata-diff-readonly";
+
+/**
+ * File system provider that serves local files as read-only.
+ * Used for displaying remote/environment files in the diff editor
+ * to prevent accidental modifications.
+ */
+export class ReadOnlyContentProvider implements vscode.FileSystemProvider {
+    private static _instance: ReadOnlyContentProvider | undefined;
+    private _disposable: vscode.Disposable | undefined;
+
+    private _onDidChangeFile = new vscode.EventEmitter<vscode.FileChangeEvent[]>();
+    readonly onDidChangeFile = this._onDidChangeFile.event;
+
+    private constructor() {
+        // Private constructor for singleton
+    }
+
+    public static getInstance(): ReadOnlyContentProvider {
+        if (!ReadOnlyContentProvider._instance) {
+            ReadOnlyContentProvider._instance = new ReadOnlyContentProvider();
+        }
+        return ReadOnlyContentProvider._instance;
+    }
+
+    /**
+     * Register the file system provider with VS Code
+     */
+    public register(): vscode.Disposable {
+        if (!this._disposable) {
+            this._disposable = vscode.workspace.registerFileSystemProvider(
+                METADATA_DIFF_READONLY_SCHEME,
+                this,
+                { isReadonly: true }
+            );
+        }
+        return this._disposable;
+    }
+
+    /**
+     * Create a read-only URI from a file path.
+     * Converts Windows paths to proper URI format (e.g., c:\Users\... -> /c:/Users/...)
+     */
+    public static createReadOnlyUri(filePath: string): vscode.Uri {
+        // Use vscode.Uri.file() to properly convert the file path to URI format,
+        // then replace the scheme with our read-only scheme
+        const fileUri = vscode.Uri.file(filePath);
+        return fileUri.with({ scheme: METADATA_DIFF_READONLY_SCHEME });
+    }
+
+    watch(): vscode.Disposable {
+        // No-op: we don't need to watch for changes on read-only files
+        return new vscode.Disposable(() => { /* no-op */ });
+    }
+
+    stat(uri: vscode.Uri): vscode.FileStat {
+        // Use fsPath to get the platform-specific file system path
+        const filePath = uri.fsPath;
+
+        if (!fs.existsSync(filePath)) {
+            throw vscode.FileSystemError.FileNotFound(uri);
+        }
+
+        const stats = fs.statSync(filePath);
+
+        return {
+            type: stats.isDirectory() ? vscode.FileType.Directory : vscode.FileType.File,
+            ctime: stats.ctimeMs,
+            mtime: stats.mtimeMs,
+            size: stats.size,
+            permissions: vscode.FilePermission.Readonly
+        };
+    }
+
+    readDirectory(): [string, vscode.FileType][] {
+        // Not needed for diff view
+        return [];
+    }
+
+    createDirectory(): void {
+        throw vscode.FileSystemError.NoPermissions("Cannot create directory: read-only file system");
+    }
+
+    readFile(uri: vscode.Uri): Uint8Array {
+        // Use fsPath to get the platform-specific file system path
+        const filePath = uri.fsPath;
+
+        if (!fs.existsSync(filePath)) {
+            throw vscode.FileSystemError.FileNotFound(uri);
+        }
+
+        return fs.readFileSync(filePath);
+    }
+
+    writeFile(): void {
+        throw vscode.FileSystemError.NoPermissions("Cannot write: read-only file system");
+    }
+
+    delete(): void {
+        throw vscode.FileSystemError.NoPermissions("Cannot delete: read-only file system");
+    }
+
+    rename(): void {
+        throw vscode.FileSystemError.NoPermissions("Cannot rename: read-only file system");
+    }
+
+    public dispose(): void {
+        this._disposable?.dispose();
+        this._onDidChangeFile.dispose();
+    }
+}
diff --git a/src/client/power-pages/actions-hub/handlers/metadata-diff/OpenAllMetadataDiffsHandler.ts b/src/client/power-pages/actions-hub/handlers/metadata-diff/OpenAllMetadataDiffsHandler.ts
@@ -9,6 +9,7 @@ import { traceInfo } from "../../TelemetryHelper";
 import { Constants } from "../../Constants";
 import { FileComparisonStatus, IFileComparisonResult } from "../../models/IFileComparisonResult";
 import { isBinaryFile } from "../../ActionsHubUtils";
+import { ReadOnlyContentProvider } from "../../ReadOnlyContentProvider";
 
 /**
  * Opens all file diffs in the multi-diff editor for a specific site
@@ -49,9 +50,10 @@ export async function openAllMetadataDiffs(siteItem: MetadataDiffSiteTreeItem):
     // Show the multi-diff editor only for text files
     if (textFiles.length > 0) {
         // Create resource list for the changes editor
+        // Original (remote) files use a read-only URI scheme to prevent accidental modifications
         const resourceList: [vscode.Uri, vscode.Uri | undefined, vscode.Uri | undefined][] = textFiles.map(result => {
             const labelUri = vscode.Uri.parse(`diff-label:${result.relativePath}`);
-            const originalUri = vscode.Uri.file(result.remotePath);
+            const originalUri = ReadOnlyContentProvider.createReadOnlyUri(result.remotePath);
             const modifiedUri = vscode.Uri.file(result.localPath);
 
             if (result.status === FileComparisonStatus.DELETED) {
diff --git a/src/client/power-pages/actions-hub/handlers/metadata-diff/OpenMetadataDiffFileHandler.ts b/src/client/power-pages/actions-hub/handlers/metadata-diff/OpenMetadataDiffFileHandler.ts
@@ -10,6 +10,7 @@ import { traceInfo } from "../../TelemetryHelper";
 import { Constants } from "../../Constants";
 import { FileComparisonStatus } from "../../models/IFileComparisonResult";
 import { isBinaryFile } from "../../ActionsHubUtils";
+import { ReadOnlyContentProvider } from "../../ReadOnlyContentProvider";
 
 /**
  * Opens a single file diff in the VS Code diff editor
@@ -38,25 +39,27 @@ export async function openMetadataDiffFile(fileItem: MetadataDiffFileTreeItem):
         return;
     }
 
-    // Handle different diff scenarios based on file status
+    // Handle different scenarios based on file status
+    // For added/deleted files, show single file view (like git)
+    // For modified files, show diff with remote as read-only
     if (comparisonResult.status === FileComparisonStatus.DELETED) {
-        // File exists in remote but not locally - show remote on left, empty on right
-        const remoteUri = vscode.Uri.file(comparisonResult.remotePath);
+        // File exists in remote but not locally - show remote file only (read-only)
+        const remoteUri = ReadOnlyContentProvider.createReadOnlyUri(comparisonResult.remotePath);
 
         if (fs.existsSync(comparisonResult.remotePath)) {
-            // Show the remote file only (since local doesn't exist)
-            await vscode.commands.executeCommand("vscode.diff", remoteUri, vscode.Uri.parse("untitled:"), title);
+            await vscode.commands.executeCommand("vscode.open", remoteUri);
         }
     } else if (comparisonResult.status === FileComparisonStatus.ADDED) {
-        // File exists locally but not in remote - show empty on left, local on right
+        // File exists locally but not in remote - show local file only
         const localUri = vscode.Uri.file(comparisonResult.localPath);
 
         if (fs.existsSync(comparisonResult.localPath)) {
-            await vscode.commands.executeCommand("vscode.diff", vscode.Uri.parse("untitled:"), localUri, title);
+            await vscode.commands.executeCommand("vscode.open", localUri);
         }
     } else {
         // Modified - both exist, show standard diff
-        const remoteUri = vscode.Uri.file(comparisonResult.remotePath);
+        // Remote (left side) is read-only, local (right side) is editable
+        const remoteUri = ReadOnlyContentProvider.createReadOnlyUri(comparisonResult.remotePath);
         const localUri = vscode.Uri.file(comparisonResult.localPath);
 
         if (fs.existsSync(comparisonResult.remotePath) && fs.existsSync(comparisonResult.localPath)) {
@@ -73,9 +76,9 @@ export async function openMetadataDiffFile(fileItem: MetadataDiffFileTreeItem):
  */
 async function openBinaryFile(localPath: string, remotePath: string, status: string): Promise<void> {
     if (status === FileComparisonStatus.DELETED) {
-        // For deleted files, the file only exists in remote
+        // For deleted files, the file only exists in remote (read-only)
         if (fs.existsSync(remotePath)) {
-            await vscode.commands.executeCommand("vscode.open", vscode.Uri.file(remotePath));
+            await vscode.commands.executeCommand("vscode.open", ReadOnlyContentProvider.createReadOnlyUri(remotePath));
         }
     } else if (status === FileComparisonStatus.ADDED) {
         // For added files, open the local version
@@ -84,17 +87,18 @@ async function openBinaryFile(localPath: string, remotePath: string, status: str
         }
     } else {
         // For modified files, open both remote and local side by side for visual comparison
+        // Remote file is read-only
         if (fs.existsSync(remotePath) && fs.existsSync(localPath)) {
-            // Open remote file in the first editor group (left side)
-            await vscode.commands.executeCommand("vscode.open", vscode.Uri.file(remotePath), vscode.ViewColumn.One);
+            // Open remote file in the first editor group (left side) - read-only
+            await vscode.commands.executeCommand("vscode.open", ReadOnlyContentProvider.createReadOnlyUri(remotePath), vscode.ViewColumn.One);
             // Open local file in the second editor group (right side)
             await vscode.commands.executeCommand("vscode.open", vscode.Uri.file(localPath), vscode.ViewColumn.Two);
         } else if (fs.existsSync(localPath)) {
             // Fallback: if only local exists, just open it
             await vscode.commands.executeCommand("vscode.open", vscode.Uri.file(localPath));
         } else if (fs.existsSync(remotePath)) {
-            // Fallback: if only remote exists, just open it
-            await vscode.commands.executeCommand("vscode.open", vscode.Uri.file(remotePath));
+            // Fallback: if only remote exists, just open it (read-only)
+            await vscode.commands.executeCommand("vscode.open", ReadOnlyContentProvider.createReadOnlyUri(remotePath));
         }
     }
 }
diff --git a/src/client/test/Integration/power-pages/actions-hub/ReadOnlyContentProvider.test.ts b/src/client/test/Integration/power-pages/actions-hub/ReadOnlyContentProvider.test.ts
@@ -0,0 +1,94 @@
+/*
+ * Copyright (c) Microsoft Corporation. All rights reserved.
+ * Licensed under the MIT License. See License.txt in the project root for license information.
+ */
+
+import { expect } from "chai";
+import * as vscode from "vscode";
+import { ReadOnlyContentProvider, METADATA_DIFF_READONLY_SCHEME } from "../../../../power-pages/actions-hub/ReadOnlyContentProvider";
+
+describe("ReadOnlyContentProvider", () => {
+    describe("getInstance", () => {
+        it("should return the same instance on multiple calls", () => {
+            const instance1 = ReadOnlyContentProvider.getInstance();
+            const instance2 = ReadOnlyContentProvider.getInstance();
+
+            expect(instance1).to.equal(instance2);
+        });
+    });
+
+    describe("createReadOnlyUri", () => {
+        it("should create URI with the correct scheme", () => {
+            const filePath = "/path/to/file.txt";
+            const uri = ReadOnlyContentProvider.createReadOnlyUri(filePath);
+
+            expect(uri.scheme).to.equal(METADATA_DIFF_READONLY_SCHEME);
+        });
+
+        it("should preserve the file path in the URI", () => {
+            const filePath = "/path/to/file.txt";
+            const uri = ReadOnlyContentProvider.createReadOnlyUri(filePath);
+
+            expect(uri.fsPath).to.include("file.txt");
+        });
+
+        it("should handle Windows paths correctly", () => {
+            const filePath = "C:\\Users\\test\\file.txt";
+            const uri = ReadOnlyContentProvider.createReadOnlyUri(filePath);
+
+            expect(uri.scheme).to.equal(METADATA_DIFF_READONLY_SCHEME);
+            // The path should be properly converted to URI format
+            expect(uri.path).to.match(/^\/[cC]:\//);
+        });
+
+        it("should handle paths with spaces", () => {
+            const filePath = "/path/to/my file.txt";
+            const uri = ReadOnlyContentProvider.createReadOnlyUri(filePath);
+
+            expect(uri.scheme).to.equal(METADATA_DIFF_READONLY_SCHEME);
+            expect(uri.fsPath).to.include("my file.txt");
+        });
+    });
+
+    describe("write operations", () => {
+        it("should throw NoPermissions on writeFile", () => {
+            const provider = ReadOnlyContentProvider.getInstance();
+
+            expect(() => provider.writeFile()).to.throw();
+        });
+
+        it("should throw NoPermissions on delete", () => {
+            const provider = ReadOnlyContentProvider.getInstance();
+
+            expect(() => provider.delete()).to.throw();
+        });
+
+        it("should throw NoPermissions on rename", () => {
+            const provider = ReadOnlyContentProvider.getInstance();
+
+            expect(() => provider.rename()).to.throw();
+        });
+
+        it("should throw NoPermissions on createDirectory", () => {
+            const provider = ReadOnlyContentProvider.getInstance();
+
+            expect(() => provider.createDirectory()).to.throw();
+        });
+    });
+
+    describe("watch", () => {
+        it("should return a Disposable", () => {
+            const provider = ReadOnlyContentProvider.getInstance();
+
+            const disposable = provider.watch();
+
+            expect(disposable).to.be.instanceOf(vscode.Disposable);
+        });
+    });
+
+    describe("METADATA_DIFF_READONLY_SCHEME", () => {
+        it("should be the expected scheme value", () => {
+            expect(METADATA_DIFF_READONLY_SCHEME).to.equal("pp-metadata-diff-readonly");
+        });
+    });
+});
diff --git a/src/client/test/Integration/power-pages/actions-hub/handlers/metadata-diff/OpenAllMetadataDiffsHandler.test.ts b/src/client/test/Integration/power-pages/actions-hub/handlers/metadata-diff/OpenAllMetadataDiffsHandler.test.ts
@@ -11,6 +11,7 @@ import { isBinaryFile } from "../../../../../../power-pages/actions-hub/ActionsH
 import { MetadataDiffSiteTreeItem } from "../../../../../../power-pages/actions-hub/tree-items/metadata-diff/MetadataDiffSiteTreeItem";
 import * as TelemetryHelper from "../../../../../../power-pages/actions-hub/TelemetryHelper";
 import { IFileComparisonResult, ISiteComparisonResults } from "../../../../../../power-pages/actions-hub/models/IFileComparisonResult";
+import { METADATA_DIFF_READONLY_SCHEME } from "../../../../../../power-pages/actions-hub/ReadOnlyContentProvider";
 
 /**
  * Helper function to create ISiteComparisonResults for testing
@@ -319,5 +320,47 @@ describe("OpenAllMetadataDiffsHandler", () => {
                 textFilesIncluded: "1"
             });
         });
+
+        it("should use read-only scheme for original (remote) URIs", async () => {
+            const results: IFileComparisonResult[] = [
+                {
+                    localPath: "/local/file.txt",
+                    remotePath: "/remote/file.txt",
+                    relativePath: "file.txt",
+                    status: "modified"
+                }
+            ];
+            const siteItem = new MetadataDiffSiteTreeItem(createSiteResults(results));
+
+            await openAllMetadataDiffs(siteItem);
+
+            const resourceList = executeCommandStub.firstCall.args[2];
+            const [, originalUri, modifiedUri] = resourceList[0];
+
+            // Original (remote) file should use read-only scheme
+            expect(originalUri.scheme).to.equal(METADATA_DIFF_READONLY_SCHEME);
+            // Modified (local) file should use regular file scheme
+            expect(modifiedUri.scheme).to.equal("file");
+        });
+
+        it("should use read-only scheme for deleted files original URI", async () => {
+            const results: IFileComparisonResult[] = [
+                {
+                    localPath: "/local/deleted.txt",
+                    remotePath: "/remote/deleted.txt",
+                    relativePath: "deleted.txt",
+                    status: "deleted"
+                }
+            ];
+            const siteItem = new MetadataDiffSiteTreeItem(createSiteResults(results));
+
+            await openAllMetadataDiffs(siteItem);
+
+            const resourceList = executeCommandStub.firstCall.args[2];
+            const [, originalUri] = resourceList[0];
+
+            // Deleted file's original (remote) URI should use read-only scheme
+            expect(originalUri.scheme).to.equal(METADATA_DIFF_READONLY_SCHEME);
+        });
     });
 });
diff --git a/src/client/test/Integration/power-pages/actions-hub/handlers/metadata-diff/OpenMetadataDiffFileHandler.test.ts b/src/client/test/Integration/power-pages/actions-hub/handlers/metadata-diff/OpenMetadataDiffFileHandler.test.ts
