();
+ diffFiles.forEach(file => {
+ const dirPath = path.dirname(file.relativePath) || '.';
+ if (!folderStructure.has(dirPath)) {
+ folderStructure.set(dirPath, []);
+ }
+ folderStructure.get(dirPath)!.push(file);
+ });
+
+ const sortedFolders = Array.from(folderStructure.keys()).sort();
+
+ // Escape for both element text and attribute contexts. Adds quotes to address CodeQL finding.
+ const escapeHtml = (value: string | undefined) => (value || '')
+ .replace(/&/g, '&')
+ .replace(//g, '>')
+ .replace(/"/g, '"')
+ .replace(/'/g, ''');
+
+ let body = `Power Pages Metadata Diff Report
`;
+ body += `Generated on: ${escapeHtml(generatedOn)}
`;
+
+ if (sortedFolders.length === 0) {
+ body += 'No differences found.
';
+ }
+
+ for (const folder of sortedFolders) {
+ const files = folderStructure.get(folder)!;
+ const folderId = folder === '.' ? 'root' : folder;
+ if (folder !== '.') {
+ body += `${escapeHtml(folder)}
`;
+ } else {
+ body += `Root
`;
+ }
+ body += `';
+ }
+
+ // Lightweight styling – no external dependencies.
+ const html = `
+${body}`;
+
+ return html;
+}
+
+/**
+ * Finds differences between two YAML objects and returns a list of changes
+ * @param workspaceObj The workspace YAML object
+ * @param storageObj The storage YAML object
+ * @returns An array of change descriptions
+ */
+function findYamlPropertyChanges(workspaceObj: unknown, storageObj: unknown, path = ''): string[] {
+ const isObj = (o: unknown): o is Record => typeof o === 'object' && o !== null && !Array.isArray(o);
+ if (!isObj(workspaceObj) || !isObj(storageObj)) {
+ return [];
+ }
+
+ const changes: string[] = [];
+ const workspaceKeys = Object.keys(workspaceObj);
+ for (const key of workspaceKeys) {
+ const currentPath = path ? `${path}.${key}` : key;
+ if (!(key in storageObj)) {
+ changes.push(`Added property: \`${currentPath}\``);
+ continue;
+ }
+ const wVal = workspaceObj[key];
+ const sVal = (storageObj as Record)[key];
+ if (isObj(wVal) && isObj(sVal)) {
+ changes.push(...findYamlPropertyChanges(wVal, sVal, currentPath));
+ } else if (JSON.stringify(wVal) !== JSON.stringify(sVal)) {
+ changes.push(`Modified property: \`${currentPath}\``);
+ }
+ }
+ const storageKeys = Object.keys(storageObj);
+ for (const key of storageKeys) {
+ if (!(key in workspaceObj)) {
+ const currentPath = path ? `${path}.${key}` : key;
+ changes.push(`Removed property: \`${currentPath}\``);
+ }
+ }
+ return changes;
+}
+
+export async function getAllDiffFiles(workspacePath: string, storagePath: string): Promise {
+ const diffFiles: DiffFile[] = [];
+
+ // Get website directory from storage path
+ const folderNames = fs.readdirSync(storagePath).filter(file =>
+ fs.statSync(path.join(storagePath, file)).isDirectory()
+ );
+ if (folderNames.length === 0) {
+ return diffFiles;
+ }
+ const websitePath = path.join(storagePath, folderNames[0]);
+
+ // Get all files
+ const workspaceFiles = await getAllFiles(workspacePath);
+ const storageFiles = await getAllFiles(websitePath);
+
+ // Create normalized path maps
+ const workspaceMap = new Map(workspaceFiles.map(f => {
+ const normalized = path.relative(workspacePath, f).replace(/\\/g, '/');
+ return [normalized, f];
+ }));
+ const storageMap = new Map(storageFiles.map(f => {
+ const normalized = path.relative(websitePath, f).replace(/\\/g, '/');
+ return [normalized, f];
+ }));
+
+ // Compare files
+ for (const [normalized, workspaceFile] of workspaceMap.entries()) {
+ const storageFile = storageMap.get(normalized);
+ if (!storageFile) {
+ diffFiles.push({
+ relativePath: normalized,
+ changes: 'Only in Local',
+ type: path.dirname(normalized) || 'Other',
+ workspaceContent: fs.readFileSync(workspaceFile, 'utf8').replace(/\r\n/g, '\n')
+ });
+ continue;
+ }
+
+ // Compare content
+ const workspaceContent = fs.readFileSync(workspaceFile, 'utf8').replace(/\r\n/g, '\n');
+ const storageContent = fs.readFileSync(storageFile, 'utf8').replace(/\r\n/g, '\n');
+ if (workspaceContent !== storageContent) {
+ diffFiles.push({
+ relativePath: normalized,
+ changes: 'Modified',
+ type: path.dirname(normalized) || 'Other',
+ workspaceContent,
+ storageContent
+ });
+ }
+ }
+
+ // Check for files only in storage
+ for (const [normalized, storageFile] of storageMap.entries()) {
+ if (!workspaceMap.has(normalized)) {
+ diffFiles.push({
+ relativePath: normalized,
+ changes: 'Only in Environment',
+ type: path.dirname(normalized) || 'Other',
+ storageContent: fs.readFileSync(storageFile, 'utf8').replace(/\r\n/g, '\n')
+ });
+ }
+ }
+
+ return diffFiles;
+}
+
+export async function getAllFiles(dirPath: string): Promise {
+ const files: string[] = [];
+
+ function traverse(currentPath: string) {
+ const entries = fs.readdirSync(currentPath, { withFileTypes: true });
+ for (const entry of entries) {
+ const fullPath = path.join(currentPath, entry.name);
+ if (entry.isDirectory()) {
+ traverse(fullPath);
+ } else {
+ files.push(fullPath);
+ }
+ }
+ }
+
+ traverse(dirPath);
+ return files;
+}
+
+export function groupDiffsByType(files: DiffFile[]): Record {
+ return files.reduce((groups: Record, file) => {
+ const type = file.type || 'Other';
+ if (!groups[type]) {
+ groups[type] = [];
+ }
+ groups[type].push(file);
+ return groups;
+ }, {});
+}
diff --git a/src/client/test/Integration/power-pages/actions-hub/ActionsHubCommandHandlers.test.ts b/src/client/test/Integration/power-pages/actions-hub/ActionsHubCommandHandlers.test.ts
index 199134cac..e537fd6f1 100644
--- a/src/client/test/Integration/power-pages/actions-hub/ActionsHubCommandHandlers.test.ts
+++ b/src/client/test/Integration/power-pages/actions-hub/ActionsHubCommandHandlers.test.ts
@@ -6,7 +6,7 @@
import { expect } from 'chai';
import * as sinon from 'sinon';
import * as vscode from 'vscode';
-import { showEnvironmentDetails, refreshEnvironment, switchEnvironment, openActiveSitesInStudio, openInactiveSitesInStudio, createNewAuthProfile, previewSite, fetchWebsites, revealInOS, uploadSite, createKnownSiteIdsSet, findOtherSites, showSiteDetails, openSiteManagement, downloadSite, openInStudio, runCodeQLScreening, loginToMatch } from '../../../../power-pages/actions-hub/ActionsHubCommandHandlers';
+import { showEnvironmentDetails, refreshEnvironment, switchEnvironment, openActiveSitesInStudio, openInactiveSitesInStudio, createNewAuthProfile, previewSite, fetchWebsites, revealInOS, uploadSite, createKnownSiteIdsSet, findOtherSites, showSiteDetails, compareWithLocal, openSiteManagement, downloadSite, openInStudio, runCodeQLScreening, loginToMatch } from '../../../../power-pages/actions-hub/ActionsHubCommandHandlers';
import { Constants } from '../../../../power-pages/actions-hub/Constants';
import * as CommonUtils from '../../../../power-pages/commonUtility';
import { AuthInfo, CloudInstance, EnvironmentType, OrgInfo } from '../../../../pac/PacTypes';
@@ -1270,6 +1270,67 @@ describe('ActionsHubCommandHandlers', () => {
});
});
+ describe('compareWithLocal', () => {
+ let mockExecuteCommand: sinon.SinonStub;
+ let mockSiteTreeItem: SiteTreeItem;
+
+ beforeEach(() => {
+ mockExecuteCommand = sandbox.stub(vscode.commands, 'executeCommand');
+ mockSiteTreeItem = new SiteTreeItem({
+ name: "Test Site",
+ websiteId: "test-id",
+ dataModelVersion: 1,
+ status: WebsiteStatus.Active,
+ websiteUrl: 'https://test-site.com',
+ isCurrent: false,
+ siteVisibility: SiteVisibility.Public,
+ siteManagementUrl: "https://test-site-management.com",
+ createdOn: "2025-03-20",
+ creator: "Test Creator",
+ isCodeSite: false
+ });
+ });
+
+ it('should execute metadata diff trigger flow command with site ID', async () => {
+ await compareWithLocal(mockSiteTreeItem);
+
+ expect(mockExecuteCommand.calledOnce).to.be.true;
+ expect(mockExecuteCommand.firstCall.args[0]).to.equal('microsoft.powerplatform.pages.metadataDiff.triggerFlowWithSite');
+ expect(mockExecuteCommand.firstCall.args[1]).to.equal('test-id');
+ });
+
+ it('should handle errors gracefully', async () => {
+ const error = new Error('Command execution failed');
+ mockExecuteCommand.rejects(error);
+
+ await compareWithLocal(mockSiteTreeItem);
+
+ expect(mockExecuteCommand.calledOnce).to.be.true;
+ expect(traceErrorStub.calledOnce).to.be.true;
+ expect(traceErrorStub.firstCall.args[0]).to.equal(Constants.EventNames.ACTIONS_HUB_COMPARE_WITH_LOCAL_FAILED);
+ expect(traceErrorStub.firstCall.args[1]).to.equal(error);
+ expect(traceErrorStub.firstCall.args[2]).to.deep.equal({
+ methodName: 'compareWithLocal',
+ siteId: 'test-id',
+ dataModelVersion: 1
+ });
+ });
+
+ it('should log telemetry when command is called', async () => {
+ const traceInfoStub = TelemetryHelper.traceInfo as sinon.SinonStub;
+
+ await compareWithLocal(mockSiteTreeItem);
+
+ expect(traceInfoStub.calledOnce).to.be.true;
+ expect(traceInfoStub.firstCall.args[0]).to.equal(Constants.EventNames.ACTIONS_HUB_COMPARE_WITH_LOCAL_CALLED);
+ expect(traceInfoStub.firstCall.args[1]).to.deep.equal({
+ methodName: 'compareWithLocal',
+ siteId: 'test-id',
+ dataModelVersion: 1
+ });
+ });
+ });
+
describe('downloadSite', () => {
let dirnameSpy: sinon.SinonSpy;
let mockSendText: sinon.SinonStub;
diff --git a/src/client/test/Integration/power-pages/actions-hub/ActionsHubTreeDataProvider.test.ts b/src/client/test/Integration/power-pages/actions-hub/ActionsHubTreeDataProvider.test.ts
index 43499285f..6fac826ec 100644
--- a/src/client/test/Integration/power-pages/actions-hub/ActionsHubTreeDataProvider.test.ts
+++ b/src/client/test/Integration/power-pages/actions-hub/ActionsHubTreeDataProvider.test.ts
@@ -218,6 +218,18 @@ describe("ActionsHubTreeDataProvider", () => {
expect(mockCommandHandler.calledOnce).to.be.true;
});
+ it("should register compareWithLocal command", async () => {
+ const mockCommandHandler = sinon.stub(CommandHandlers, 'compareWithLocal');
+ mockCommandHandler.resolves();
+ const actionsHubTreeDataProvider = ActionsHubTreeDataProvider.initialize(context, pacTerminal, false);
+ actionsHubTreeDataProvider["registerPanel"](pacTerminal);
+
+ expect(registerCommandStub.calledWith("microsoft.powerplatform.pages.actionsHub.compareWithLocal")).to.be.true;
+
+ await registerCommandStub.getCall(13).args[1]();
+ expect(mockCommandHandler.calledOnce).to.be.true;
+ });
+
it("should register downloadSite command", async () => {
const mockCommandHandler = sinon.stub(CommandHandlers, 'downloadSite');
mockCommandHandler.resolves();
@@ -226,7 +238,7 @@ describe("ActionsHubTreeDataProvider", () => {
expect(registerCommandStub.calledWith("microsoft.powerplatform.pages.actionsHub.activeSite.downloadSite")).to.be.true;
- await registerCommandStub.getCall(13).args[1]();
+ await registerCommandStub.getCall(14).args[1]();
expect(mockCommandHandler.calledOnce).to.be.true;
});
@@ -238,7 +250,7 @@ describe("ActionsHubTreeDataProvider", () => {
expect(registerCommandStub.calledWith("microsoft.powerplatform.pages.actionsHub.activeSite.openInStudio")).to.be.true;
- await registerCommandStub.getCall(14).args[1]();
+ await registerCommandStub.getCall(15).args[1]();
expect(mockCommandHandler.calledOnce).to.be.true;
});
diff --git a/src/client/test/unit/power-pages/metadata-diff/MetadataDiffUtils.test.ts b/src/client/test/unit/power-pages/metadata-diff/MetadataDiffUtils.test.ts
new file mode 100644
index 000000000..835e038d7
--- /dev/null
+++ b/src/client/test/unit/power-pages/metadata-diff/MetadataDiffUtils.test.ts
@@ -0,0 +1,44 @@
+/*
+ * 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 fs from "fs";
+import * as path from "path";
+import { generateDiffReport } from "../../../../power-pages/metadata-diff/MetadataDiffUtils";
+
+// Simple helper to create temp folder structure
+function makeTempDir(): string {
+ const dir = fs.mkdtempSync(path.join(process.cwd(), "mdiff-util-test-"));
+ return dir;
+}
+
+describe("MetadataDiffUtils.generateDiffReport", () => {
+ it("escapes HTML special chars and sanitizes class names", async () => {
+ const workspace = makeTempDir();
+ const storageRoot = makeTempDir();
+ // Simulate downloaded folder structure: storageRoot/siteA/
+ const siteDir = path.join(storageRoot, "siteA");
+ fs.mkdirSync(siteDir, { recursive: true });
+
+ // File present in workspace only (attempt injection via filename / contents is not used in class)
+ fs.writeFileSync(path.join(workspace, 'onlyLocal.txt'), 'local');
+ // File present in storage only
+ fs.writeFileSync(path.join(siteDir, 'onlyRemote.txt'), 'remote');
+ // Modified file with differing content
+ fs.writeFileSync(path.join(workspace, 'mod.html'), 'local & update
');
+ fs.writeFileSync(path.join(siteDir, 'mod.html'), 'remote & update
');
+
+ const html = await generateDiffReport(workspace, storageRoot);
+ // Ensure potentially unsafe characters from content are escaped (should not appear raw)
+ expect(html).to.not.contain('local & update
');
+ expect(html).to.not.contain('remote & update
');
+ // Class names should be canonical; no raw 'only-in-local' transformation injection beyond whitelist
+ expect(html).to.match(/file-item only-in-local/);
+ expect(html).to.match(/file-item only-in-environment/);
+ expect(html).to.match(/file-item modified/);
+ // Should not contain unescaped quotes in attributes leading to potential breakouts
+ expect(html).to.not.contain('class="file-item modified""');
+ });
+});
diff --git a/src/common/ecs-features/ecsFeatureGates.ts b/src/common/ecs-features/ecsFeatureGates.ts
index f1b2d7da2..ce7fdb158 100644
--- a/src/common/ecs-features/ecsFeatureGates.ts
+++ b/src/common/ecs-features/ecsFeatureGates.ts
@@ -99,3 +99,13 @@ export const {
enableCodeQlScan: false,
}
})
+
+export const {
+ feature: EnableMetadataDiff
+} = getFeatureConfigs({
+ teamName: PowerPagesClientName,
+ description: 'Enable Metadata Diff comparison in VS Code',
+ fallback: {
+ enableMetadataDiff: false,
+ },
+});
diff --git a/src/common/power-pages/metadata-diff/Constants.ts b/src/common/power-pages/metadata-diff/Constants.ts
new file mode 100644
index 000000000..fac84bd5c
--- /dev/null
+++ b/src/common/power-pages/metadata-diff/Constants.ts
@@ -0,0 +1,63 @@
+/*
+ * Copyright (c) Microsoft Corporation. All rights reserved.
+ * Licensed under the MIT License. See License.txt in the project root for license information.
+ */
+
+export const Constants = {
+ EventNames: {
+ METADATA_DIFF_INITIALIZED: "metadataDiffInitialized",
+ METADATA_DIFF_REFRESH_FAILED: "metadataDiffRefreshFailed",
+ METADATA_DIFF_INITIALIZATION_FAILED: "metadataDiffInitializationFailed",
+ METADATA_DIFF_CURRENT_ENV_FETCH_FAILED: "metadataDiffCurrentEnvFetchFailed",
+ METADATA_DIFF_CLEAR_CALLED: "metadataDiffClearCalled",
+ METADATA_DIFF_CLEAR_FAILED: "metadataDiffClearFailed",
+ METADATA_DIFF_GET_CHILDREN_CALLED: "metadataDiffGetChildrenCalled",
+ METADATA_DIFF_GET_CHILDREN_COMPLETED: "metadataDiffGetChildrenCompleted",
+ METADATA_DIFF_SET_FILES_CALLED: "metadataDiffSetFilesCalled",
+ METADATA_DIFF_SET_FILES_COMPLETED: "metadataDiffSetFilesCompleted",
+ METADATA_DIFF_SET_FILES_FAILED: "metadataDiffSetFilesFailed",
+ ORGANIZATION_URL_MISSING: "Organization URL is missing in the results.",
+ EMPTY_RESULTS_ARRAY: "Results array is empty or not an array.",
+ PAC_AUTH_OUTPUT_FAILURE: "pacAuthCreateOutput is missing or unsuccessful.",
+ METADATA_DIFF_REPORT_FAILED: "metadataDiffReportFailed",
+ // Enhanced telemetry events (added v1.1)
+ METADATA_DIFF_TRIGGER_FLOW_CALLED: "metadataDiffTriggerFlowCalled",
+ METADATA_DIFF_TRIGGER_FLOW_SUCCEEDED: "metadataDiffTriggerFlowSucceeded",
+ METADATA_DIFF_TRIGGER_FLOW_FAILED: "metadataDiffTriggerFlowFailed",
+ METADATA_DIFF_TRIGGER_FLOW_WITH_SITE_CALLED: "metadataDiffTriggerFlowWithSiteCalled",
+ METADATA_DIFF_TRIGGER_FLOW_WITH_SITE_SUCCEEDED: "metadataDiffTriggerFlowWithSiteSucceeded",
+ METADATA_DIFF_TRIGGER_FLOW_WITH_SITE_FAILED: "metadataDiffTriggerFlowWithSiteFailed",
+ METADATA_DIFF_RESYNC_CALLED: "metadataDiffResyncCalled",
+ METADATA_DIFF_RESYNC_SUCCEEDED: "metadataDiffResyncSucceeded",
+ METADATA_DIFF_RESYNC_FAILED: "metadataDiffResyncFailed",
+ METADATA_DIFF_DOWNLOAD_STARTED: "metadataDiffDownloadStarted",
+ METADATA_DIFF_DOWNLOAD_COMPLETED: "metadataDiffDownloadCompleted",
+ METADATA_DIFF_DOWNLOAD_FAILED: "metadataDiffDownloadFailed",
+ METADATA_DIFF_DIFF_BUILD_STARTED: "metadataDiffDiffBuildStarted",
+ METADATA_DIFF_DIFF_BUILD_COMPLETED: "metadataDiffDiffBuildCompleted",
+ METADATA_DIFF_FILE_COUNTS: "metadataDiffFileCounts",
+ METADATA_DIFF_NO_DIFFERENCES: "metadataDiffNoDifferences",
+ METADATA_DIFF_OPEN_DIFF_CALLED: "metadataDiffOpenDiffCalled",
+ METADATA_DIFF_OPEN_DIFF_SUCCEEDED: "metadataDiffOpenDiffSucceeded",
+ METADATA_DIFF_OPEN_DIFF_FAILED: "metadataDiffOpenDiffFailed",
+ METADATA_DIFF_DISCARD_LOCAL_CALLED: "metadataDiffDiscardLocalCalled",
+ METADATA_DIFF_DISCARD_LOCAL_SUCCEEDED: "metadataDiffDiscardLocalSucceeded",
+ METADATA_DIFF_DISCARD_LOCAL_FAILED: "metadataDiffDiscardLocalFailed",
+ METADATA_DIFF_REPORT_GENERATE_CALLED: "metadataDiffReportGenerateCalled",
+ METADATA_DIFF_REPORT_GENERATE_SUCCEEDED: "metadataDiffReportGenerateSucceeded",
+ METADATA_DIFF_REPORT_GENERATE_FAILED: "metadataDiffReportGenerateFailed",
+ METADATA_DIFF_REPORT_EXPORT_CALLED: "metadataDiffReportExportCalled",
+ METADATA_DIFF_REPORT_EXPORT_SUCCEEDED: "metadataDiffReportExportSucceeded",
+ METADATA_DIFF_REPORT_EXPORT_FAILED: "metadataDiffReportExportFailed",
+ METADATA_DIFF_REPORT_IMPORT_CALLED: "metadataDiffReportImportCalled",
+ METADATA_DIFF_REPORT_IMPORT_SUCCEEDED: "metadataDiffReportImportSucceeded",
+ METADATA_DIFF_REPORT_IMPORT_FAILED: "metadataDiffReportImportFailed",
+ METADATA_DIFF_PERF_SUMMARY: "metadataDiffPerfSummary",
+ METADATA_DIFF_CLEAR_SUCCEEDED: "metadataDiffClearSucceeded",
+ METADATA_DIFF_ROOT_RENDERED: "metadataDiffRootRendered",
+ METADATA_DIFF_OPEN_COMPARISON_CALLED: "metadataDiffOpenComparisonCalled",
+ METADATA_DIFF_OPEN_COMPARISON_FAILED: "metadataDiffOpenComparisonFailed",
+ METADATA_DIFF_OPEN_COMPARISON_SUCCEEDED: "metadataDiffOpenComparisonSucceeded"
+ }
+};
+export const SUCCESS = "Success";
diff --git a/src/common/power-pages/metadata-diff/MetadataDiffTreeDataProvider.ts b/src/common/power-pages/metadata-diff/MetadataDiffTreeDataProvider.ts
new file mode 100644
index 000000000..65c5e3c6d
--- /dev/null
+++ b/src/common/power-pages/metadata-diff/MetadataDiffTreeDataProvider.ts
@@ -0,0 +1,399 @@
+/*
+ * 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";
+import * as path from "path";
+import { MetadataDiffTreeItem } from "./tree-items/MetadataDiffTreeItem";
+import { Constants } from "./Constants";
+import { oneDSLoggerWrapper } from "../../OneDSLoggerTelemetry/oneDSLoggerWrapper";
+import { getMetadataDiffBaseEventInfo } from "../../../client/power-pages/metadata-diff/MetadataDiffTelemetry";
+import { MetadataDiffFileItem } from "./tree-items/MetadataDiffFileItem";
+import { MetadataDiffFolderItem } from "./tree-items/MetadataDiffFolderItem";
+
+interface DiffFile {
+ relativePath: string;
+ changes: string;
+ type: string;
+ workspaceContent?: string;
+ storageContent?: string;
+}
+
+export class MetadataDiffTreeDataProvider implements vscode.TreeDataProvider {
+ private readonly _disposables: vscode.Disposable[] = [];
+ private readonly _context: vscode.ExtensionContext;
+ private _onDidChangeTreeData: vscode.EventEmitter = new vscode.EventEmitter();
+ readonly onDidChangeTreeData: vscode.Event = this._onDidChangeTreeData.event;
+ // Stored diff tree (root level items) – Actions Hub wrapper accesses this through a private field
+ // Keep name for backward compatibility with wrapper reflection access.
+ // eslint-disable-next-line @typescript-eslint/naming-convention
+ private _diffItems: MetadataDiffTreeItem[] = [];
+ // Emits when the diff data has been fully populated for the first time
+ private _onDataLoaded: vscode.EventEmitter = new vscode.EventEmitter();
+ public readonly onDataLoaded: vscode.Event = this._onDataLoaded.event;
+ private _dataLoadedNotified = false;
+ // Guard so we only emit file composition event once per build cycle
+ private _emittedFileCounts = false;
+
+ constructor(context: vscode.ExtensionContext) {
+ this._context = context;
+ }
+
+ public static initialize(context: vscode.ExtensionContext): MetadataDiffTreeDataProvider {
+ return new MetadataDiffTreeDataProvider(context);
+ }
+
+ private refresh(): void {
+ this._onDidChangeTreeData.fire();
+ }
+
+ /** Public accessor used by tests (avoids reflection) */
+ public get items(): ReadonlyArray {
+ return this._diffItems;
+ }
+
+ /**
+ * Clears existing diff items and resets provider state & contexts.
+ * Designed to be resilient – errors are logged via telemetry but not thrown.
+ */
+ clearItems(): void {
+ oneDSLoggerWrapper.getLogger().traceInfo(Constants.EventNames.METADATA_DIFF_CLEAR_CALLED, { methodName: 'clearItems' });
+ try {
+ this._diffItems = [];
+ this._dataLoadedNotified = false; // allow message again after reset
+ // Reset any stored diff import artifacts
+ const storagePath = this._context.storageUri?.fsPath;
+ if (storagePath && fs.existsSync(storagePath)) {
+ try {
+ fs.rmSync(storagePath, { recursive: true, force: true });
+ fs.mkdirSync(storagePath, { recursive: true });
+ } catch (innerError) {
+ oneDSLoggerWrapper.getLogger().traceError(
+ Constants.EventNames.METADATA_DIFF_CLEAR_FAILED,
+ innerError as string,
+ innerError as Error,
+ { methodName: 'clearItems.storageCleanup' },
+ {}
+ );
+ }
+ }
+ vscode.commands.executeCommand("setContext", "microsoft.powerplatform.pages.metadataDiff.hasData", false);
+ this._onDidChangeTreeData.fire();
+ // Refresh Actions Hub so the integrated root node updates
+ vscode.commands.executeCommand("microsoft.powerplatform.pages.actionsHub.refresh");
+ } catch (error) {
+ oneDSLoggerWrapper.getLogger().traceError(
+ Constants.EventNames.METADATA_DIFF_CLEAR_FAILED,
+ error as string,
+ error as Error,
+ { methodName: 'clearItems' },
+ {}
+ );
+ }
+ }
+
+ getTreeItem(element: MetadataDiffTreeItem): vscode.TreeItem | Thenable {
+ return element;
+ }
+
+ private getAllFilesRecursively(dir: string, fileList: string[] = []): string[] {
+ const files = fs.readdirSync(dir);
+
+ for (const file of files) {
+ const fullPath = path.join(dir, file);
+ if (fs.statSync(fullPath).isDirectory()) {
+ this.getAllFilesRecursively(fullPath, fileList);
+ } else {
+ fileList.push(fullPath);
+ }
+ }
+
+ return fileList;
+ }
+
+ private async getDiffFiles(workspacePath: string, storagePath: string): Promise> {
+ const diffFiles = new Map();
+
+ // Get website directory from storage path
+ const websitePath = await this.getWebsitePath(storagePath);
+ if (!websitePath) {
+ return diffFiles;
+ }
+
+ const workspaceFiles = this.getAllFilesRecursively(workspacePath);
+ const storageFiles = this.getAllFilesRecursively(websitePath);
+
+ // Create normalized path maps for comparison
+ const workspaceMap = new Map(workspaceFiles.map(f => {
+ const normalized = path.relative(workspacePath, f).replace(/\\/g, '/');
+ return [normalized, f];
+ }));
+
+ const storageMap = new Map(storageFiles.map(f => {
+ const normalized = path.relative(websitePath, f).replace(/\\/g, '/');
+ return [normalized, f];
+ }));
+
+ // Compare files
+ for (const [relativePath, workspaceFile] of workspaceMap.entries()) {
+ const storageFile = storageMap.get(relativePath);
+
+ if (!storageFile) {
+ // File only exists in workspace
+ diffFiles.set(relativePath, { workspaceFile });
+ continue;
+ }
+
+ // Compare content only if both files exist
+ const workspaceContent = fs.readFileSync(workspaceFile, 'utf8').replace(/\r\n/g, '\n');
+ const storageContent = fs.readFileSync(storageFile, 'utf8').replace(/\r\n/g, '\n');
+
+ if (workspaceContent !== storageContent) {
+ diffFiles.set(relativePath, { workspaceFile, storageFile });
+ }
+ }
+
+ // Check for files only in storage
+ for (const [relativePath, storageFile] of storageMap.entries()) {
+ if (!workspaceMap.has(relativePath)) {
+ diffFiles.set(relativePath, { storageFile });
+ }
+ }
+
+ return diffFiles;
+ }
+
+ private async getWebsitePath(storagePath: string): Promise {
+ try {
+ const folders = fs.readdirSync(storagePath).filter(f =>
+ fs.statSync(path.join(storagePath, f)).isDirectory()
+ );
+
+ if (folders.length > 0) {
+ return path.join(storagePath, folders[0]);
+ }
+ } catch (error) {
+ console.error('Error finding website path:', error);
+ }
+ return undefined;
+ }
+
+ async getChildren(element?: MetadataDiffTreeItem): Promise {
+ if (element) {
+ return element.getChildren();
+ }
+
+ if (this._diffItems && this._diffItems.length > 0) {
+ return this._diffItems;
+ }
+
+ oneDSLoggerWrapper.getLogger().traceInfo(Constants.EventNames.METADATA_DIFF_GET_CHILDREN_CALLED, { methodName: 'getChildren', ...getMetadataDiffBaseEventInfo() });
+ try {
+ const workspaceFolders = vscode.workspace.workspaceFolders;
+ if (!workspaceFolders) {
+ oneDSLoggerWrapper.getLogger().traceInfo(Constants.EventNames.METADATA_DIFF_GET_CHILDREN_COMPLETED, { methodName: 'getChildren', result: 'noWorkspace' });
+ return [];
+ }
+
+ const workspacePath = workspaceFolders[0].uri.fsPath;
+ const storagePath = this._context.storageUri?.fsPath;
+ if (!storagePath) {
+ throw new Error("Metadata Diff storage path is not defined");
+ }
+
+ const diffFiles = await this.getDiffFiles(workspacePath, storagePath);
+ if (diffFiles.size === 0) {
+ this._diffItems = [];
+ vscode.commands.executeCommand("setContext", "microsoft.powerplatform.pages.metadataDiff.hasData", false);
+ oneDSLoggerWrapper.getLogger().traceInfo(Constants.EventNames.METADATA_DIFF_NO_DIFFERENCES, { methodName: 'getChildren', ...getMetadataDiffBaseEventInfo() });
+ oneDSLoggerWrapper.getLogger().traceInfo(Constants.EventNames.METADATA_DIFF_GET_CHILDREN_COMPLETED, { methodName: 'getChildren', result: 'noDifferences', ...getMetadataDiffBaseEventInfo() });
+ return [];
+ }
+
+ const items = this.buildTreeHierarchy(diffFiles);
+ this._diffItems = items;
+ vscode.commands.executeCommand("setContext", "microsoft.powerplatform.pages.metadataDiff.hasData", this._diffItems.length > 0);
+ vscode.commands.executeCommand("microsoft.powerplatform.pages.actionsHub.refresh");
+ if (!this._dataLoadedNotified && this._diffItems.length > 0) {
+ this._dataLoadedNotified = true;
+ this._onDataLoaded.fire();
+ }
+ // Emit file composition metrics once
+ if (!this._emittedFileCounts) {
+ this._emittedFileCounts = true;
+ const counts = this.calculateFileCounts(diffFiles);
+ oneDSLoggerWrapper.getLogger().traceInfo(Constants.EventNames.METADATA_DIFF_FILE_COUNTS, { methodName: 'getChildren', ...counts, ...getMetadataDiffBaseEventInfo() });
+ }
+ oneDSLoggerWrapper.getLogger().traceInfo(Constants.EventNames.METADATA_DIFF_GET_CHILDREN_COMPLETED, { methodName: 'getChildren', result: 'success', itemCount: this._diffItems.length, ...getMetadataDiffBaseEventInfo() });
+ return items;
+ } catch (error) {
+ oneDSLoggerWrapper.getLogger().traceError(
+ Constants.EventNames.METADATA_DIFF_CURRENT_ENV_FETCH_FAILED,
+ error as string,
+ error as Error,
+ { methodName: 'getChildren', ...getMetadataDiffBaseEventInfo() },
+ {}
+ );
+ return null;
+ }
+ }
+
+ private buildTreeHierarchy(filePathMap: Map): MetadataDiffTreeItem[] {
+ const rootNode = new MetadataDiffFolderItem('');
+
+ for (const [relativePath, { workspaceFile, storageFile }] of filePathMap.entries()) {
+ const parts = relativePath.split('/');
+ let currentNode = rootNode;
+
+ // Create folder hierarchy
+ for (let i = 0; i < parts.length - 1; i++) {
+ const folderName = parts[i];
+ let folderNode = currentNode.getChildrenMap().get(folderName) as MetadataDiffFolderItem;
+
+ if (!folderNode) {
+ folderNode = new MetadataDiffFolderItem(folderName);
+ currentNode.getChildrenMap().set(folderName, folderNode);
+ }
+
+ currentNode = folderNode;
+ }
+
+ // Add file
+ const fileName = parts[parts.length - 1];
+ const fileNode = new MetadataDiffFileItem(
+ fileName,
+ workspaceFile,
+ storageFile,
+ true
+ );
+ fileNode.description = this.getChangeDescription(workspaceFile, storageFile);
+ currentNode.getChildrenMap().set(fileName, fileNode);
+ }
+
+ // Convert the root's children map to array
+ return Array.from(rootNode.getChildrenMap().values());
+ }
+
+ private getChangeDescription(workspaceFile?: string, storageFile?: string): string {
+ if (!workspaceFile) return vscode.l10n.t("Only in Environment");
+ if (!storageFile) return vscode.l10n.t("Only in Local");
+ return vscode.l10n.t("Modified");
+ }
+
+ /**
+ * Injects a pre-computed diff set (e.g., from imported report) replacing current state.
+ */
+ async setDiffFiles(files: DiffFile[]): Promise {
+ oneDSLoggerWrapper.getLogger().traceInfo(Constants.EventNames.METADATA_DIFF_SET_FILES_CALLED, { methodName: 'setDiffFiles', fileCount: files?.length || 0, ...getMetadataDiffBaseEventInfo() });
+ const rootNode = new MetadataDiffFolderItem('');
+ const sortedFiles = files.sort((a, b) => a.relativePath.localeCompare(b.relativePath));
+
+ // Get temp directory for storing imported file contents
+ const tempDir = path.join(this._context.storageUri?.fsPath || '', 'imported_diff');
+ if (!fs.existsSync(tempDir)) {
+ fs.mkdirSync(tempDir, { recursive: true });
+ }
+
+ try {
+ for (const file of sortedFiles) {
+ const parts = file.relativePath.split('/');
+ let currentNode = rootNode;
+
+ // Create folder hierarchy
+ for (let i = 0; i < parts.length - 1; i++) {
+ const folderName = parts[i];
+ let folderNode = currentNode.getChildrenMap().get(folderName) as MetadataDiffFolderItem;
+
+ if (!folderNode) {
+ // Create folder with expanded state in constructor
+ folderNode = new MetadataDiffFolderItem(folderName, vscode.TreeItemCollapsibleState.Expanded);
+ folderNode.iconPath = new vscode.ThemeIcon("folder");
+ currentNode.getChildrenMap().set(folderName, folderNode);
+ }
+
+ currentNode = folderNode;
+ }
+
+ // Rest of the file handling code...
+ const fileName = parts[parts.length - 1];
+ const filePath = path.join(tempDir, file.relativePath);
+ const dirPath = path.dirname(filePath);
+ fs.mkdirSync(dirPath, { recursive: true });
+
+ // Extract original file extension to preserve it
+ const fileExt = path.extname(fileName);
+
+ let workspaceFilePath: string | undefined;
+ let storageFilePath: string | undefined;
+
+ if (file.workspaceContent) {
+ // Use the original file extension in the temp file to preserve language identification
+ workspaceFilePath = `${filePath}.workspace${fileExt}`;
+ fs.writeFileSync(workspaceFilePath, file.workspaceContent);
+ }
+
+ if (file.storageContent) {
+ // Use the original file extension in the temp file to preserve language identification
+ storageFilePath = `${filePath}.storage${fileExt}`;
+ fs.writeFileSync(storageFilePath, file.storageContent);
+ }
+
+ const fileNode = new MetadataDiffFileItem(
+ fileName,
+ workspaceFilePath,
+ storageFilePath,
+ true
+ );
+ fileNode.description = file.changes;
+ fileNode.iconPath = new vscode.ThemeIcon("file");
+ fileNode.command = {
+ command: 'metadataDiff.openDiff',
+ title: 'Show Diff',
+ arguments: [workspaceFilePath, storageFilePath]
+ };
+
+ currentNode.getChildrenMap().set(fileName, fileNode);
+ }
+
+ this._diffItems = Array.from(rootNode.getChildrenMap().values());
+ this._onDidChangeTreeData.fire();
+ vscode.commands.executeCommand("setContext", "microsoft.powerplatform.pages.metadataDiff.hasData", this._diffItems.length > 0);
+ vscode.commands.executeCommand("microsoft.powerplatform.pages.actionsHub.refresh");
+ if (!this._dataLoadedNotified && this._diffItems.length > 0) {
+ this._dataLoadedNotified = true;
+ this._onDataLoaded.fire();
+ }
+ oneDSLoggerWrapper.getLogger().traceInfo(Constants.EventNames.METADATA_DIFF_SET_FILES_COMPLETED, { methodName: 'setDiffFiles', itemCount: this._diffItems.length, ...getMetadataDiffBaseEventInfo() });
+ } catch (error) {
+ oneDSLoggerWrapper.getLogger().traceError(
+ Constants.EventNames.METADATA_DIFF_SET_FILES_FAILED,
+ error as string,
+ error as Error,
+ { methodName: 'setDiffFiles', ...getMetadataDiffBaseEventInfo() },
+ {}
+ );
+ throw error;
+ }
+ }
+
+ private calculateFileCounts(diffFiles: Map) {
+ let modified = 0; let onlyLocal = 0; let onlyEnvironment = 0;
+ const extensionCounts: Record = {};
+ for (const [relative, pair] of diffFiles.entries()) {
+ if (pair.workspaceFile && pair.storageFile) modified++; else if (pair.workspaceFile) onlyLocal++; else if (pair.storageFile) onlyEnvironment++;
+ const ext = (relative.includes('.') ? '.' + relative.split('.').pop() : '');
+ extensionCounts[ext] = (extensionCounts[ext] || 0) + 1;
+ }
+ const total = diffFiles.size;
+ // Limit histogram to top 10 extensions + other
+ const sorted = Object.entries(extensionCounts).sort((a,b) => b[1]-a[1]);
+ const top = sorted.slice(0,10);
+ const otherCount = sorted.slice(10).reduce((acc,cur)=>acc+cur[1],0);
+ const histogram: Record = {};
+ for (const [k,v] of top) histogram[k||''] = v;
+ if (otherCount>0) histogram['__other'] = otherCount;
+ return { total, modified, onlyLocal, onlyEnvironment, extensionHistogram: JSON.stringify(histogram) };
+ }
+}
diff --git a/src/common/power-pages/metadata-diff/tree-items/MetadataDiffFileItem.ts b/src/common/power-pages/metadata-diff/tree-items/MetadataDiffFileItem.ts
new file mode 100644
index 000000000..d0a69f572
--- /dev/null
+++ b/src/common/power-pages/metadata-diff/tree-items/MetadataDiffFileItem.ts
@@ -0,0 +1,48 @@
+/*
+ * 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 { MetadataDiffTreeItem } from "./MetadataDiffTreeItem";
+
+export class MetadataDiffFileItem extends MetadataDiffTreeItem {
+ constructor(label: string, workspaceFile?: string, storageFile?: string, hasDiff = true) {
+ // Derive a more specific context value so that modified items can have dedicated menu actions
+ let contextValue = "metadataDiffFileItem"; // default
+ if (workspaceFile && storageFile) {
+ contextValue = "metadataDiffFileModified"; // both sides exist and differ
+ } else if (workspaceFile && !storageFile) {
+ contextValue = "metadataDiffFileOnlyLocal";
+ } else if (!workspaceFile && storageFile) {
+ contextValue = "metadataDiffFileOnlyRemote";
+ }
+
+ super(
+ label,
+ vscode.TreeItemCollapsibleState.None,
+ contextValue,
+ workspaceFile,
+ storageFile
+ );
+ // Mirror to base properties so wrapper can access via reflection
+ this.workspaceFile = workspaceFile;
+ this.storageFile = storageFile;
+ (this as unknown as { filePath?: string }).filePath = workspaceFile;
+ (this as unknown as { storedFilePath?: string }).storedFilePath = storageFile;
+ this.hasDiff = hasDiff;
+ this.iconPath = new vscode.ThemeIcon("file");
+
+ if (hasDiff && (workspaceFile || storageFile)) {
+ this.command = {
+ command: 'metadataDiff.openDiff',
+ title: 'Show Diff',
+ arguments: [workspaceFile, storageFile]
+ };
+ }
+ }
+
+ public readonly workspaceFile?: string;
+ public readonly storageFile?: string;
+ public readonly hasDiff: boolean;
+}
diff --git a/src/common/power-pages/metadata-diff/tree-items/MetadataDiffFolderItem.ts b/src/common/power-pages/metadata-diff/tree-items/MetadataDiffFolderItem.ts
new file mode 100644
index 000000000..c2baeccbb
--- /dev/null
+++ b/src/common/power-pages/metadata-diff/tree-items/MetadataDiffFolderItem.ts
@@ -0,0 +1,14 @@
+/*
+ * 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 { MetadataDiffTreeItem } from "./MetadataDiffTreeItem";
+
+export class MetadataDiffFolderItem extends MetadataDiffTreeItem {
+ constructor(label: string, collapsibleState: vscode.TreeItemCollapsibleState = vscode.TreeItemCollapsibleState.Expanded) {
+ super(label, collapsibleState, "folder");
+ this.iconPath = new vscode.ThemeIcon("folder");
+ }
+}
diff --git a/src/common/power-pages/metadata-diff/tree-items/MetadataDiffTreeItem.ts b/src/common/power-pages/metadata-diff/tree-items/MetadataDiffTreeItem.ts
new file mode 100644
index 000000000..6ab0b9442
--- /dev/null
+++ b/src/common/power-pages/metadata-diff/tree-items/MetadataDiffTreeItem.ts
@@ -0,0 +1,42 @@
+/*
+ * 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";
+
+export class MetadataDiffTreeItem extends vscode.TreeItem {
+ private _childrenMap: Map;
+
+ constructor(
+ public readonly label: string,
+ public readonly collapsibleState: vscode.TreeItemCollapsibleState,
+ public readonly contextValue?: string,
+ public readonly filePath?: string, // Workspace file path
+ public readonly storedFilePath?: string // Backup copy path
+ ) {
+ super(label, collapsibleState);
+ this._childrenMap = new Map();
+ this.contextValue = contextValue;
+ this.iconPath = collapsibleState === vscode.TreeItemCollapsibleState.None ?
+ new vscode.ThemeIcon("file") :
+ new vscode.ThemeIcon("folder");
+ this.tooltip = this.label;
+
+ if (filePath && storedFilePath) {
+ this.command = {
+ command: "metadataDiff.openDiff",
+ title: "Open Diff",
+ arguments: [filePath, storedFilePath] // Pass file paths to the command
+ };
+ }
+ }
+
+ public getChildren(): MetadataDiffTreeItem[] {
+ return Array.from(this._childrenMap.values());
+ }
+
+ public getChildrenMap(): Map {
+ return this._childrenMap;
+ }
+}
diff --git a/src/common/test/unit/metadata-diff/MetadataDiffTreeDataProvider.test.ts b/src/common/test/unit/metadata-diff/MetadataDiffTreeDataProvider.test.ts
new file mode 100644
index 000000000..3379eb76b
--- /dev/null
+++ b/src/common/test/unit/metadata-diff/MetadataDiffTreeDataProvider.test.ts
@@ -0,0 +1,90 @@
+/*
+ * Copyright (c) Microsoft Corporation. All rights reserved.
+ * Licensed under the MIT License. See License.txt in the project root for license information.
+ */
+
+/* eslint-disable @typescript-eslint/no-explicit-any */
+// Tests for MetadataDiffTreeDataProvider
+import * as sinon from "sinon";
+import { expect } from "chai";
+import * as vscode from "vscode";
+import * as fs from "fs";
+import * as path from "path";
+import { MetadataDiffTreeDataProvider } from "../../../../common/power-pages/metadata-diff/MetadataDiffTreeDataProvider";
+import { oneDSLoggerWrapper } from "../../../../common/OneDSLoggerTelemetry/oneDSLoggerWrapper";
+
+// Helper to create a mock extension context with in-memory storage path
+function createMockContext(tmpDir: string): vscode.ExtensionContext {
+ const ctx = {
+ extensionUri: vscode.Uri.file(tmpDir),
+ storageUri: vscode.Uri.file(path.join(tmpDir, 'storage')),
+ globalStorageUri: vscode.Uri.file(path.join(tmpDir, 'gstorage')),
+ logUri: vscode.Uri.file(path.join(tmpDir, 'log')),
+ extensionPath: tmpDir,
+ globalState: { } as unknown,
+ workspaceState: { } as unknown,
+ subscriptions: [],
+ asAbsolutePath: (p: string) => path.join(tmpDir, p),
+ environmentVariableCollection: { } as unknown,
+ extensionMode: vscode.ExtensionMode.Test,
+ storagePath: path.join(tmpDir, 'storage'),
+ globalStoragePath: path.join(tmpDir, 'gstorage'),
+ logPath: path.join(tmpDir, 'log'),
+ secrets: { } as unknown,
+ extension: { } as unknown,
+ languageModelAccessInformation: { } as unknown
+ } as unknown;
+ return ctx as vscode.ExtensionContext;
+}
+
+describe("MetadataDiffTreeDataProvider", () => {
+ let sandbox: sinon.SinonSandbox;
+ let tmpDir: string;
+ let context: vscode.ExtensionContext;
+
+ beforeEach(() => {
+ sandbox = sinon.createSandbox();
+ tmpDir = fs.mkdtempSync(path.join(process.cwd(), 'mdiff-test-'));
+ context = createMockContext(tmpDir);
+ fs.mkdirSync(context.storageUri!.fsPath, { recursive: true });
+ sandbox.stub(oneDSLoggerWrapper, 'getLogger').returns({
+ traceInfo: () => {},
+ traceError: () => {}
+ } as any);
+ });
+
+ afterEach(() => {
+ sandbox.restore();
+ try { fs.rmSync(tmpDir, { recursive: true, force: true }); } catch { /* ignore */ }
+ });
+
+ it("returns empty when no workspace", async () => {
+ sandbox.stub(vscode.workspace, 'workspaceFolders').value(undefined);
+ const provider = new MetadataDiffTreeDataProvider(context);
+ const children = await provider.getChildren();
+ expect(children).to.deep.equal([]);
+ });
+
+ it("setDiffFiles populates items and contexts", async () => {
+ sandbox.stub(vscode.workspace, 'workspaceFolders').value([ { uri: vscode.Uri.file(tmpDir), name: 'ws', index: 0 } as any ]);
+ const execSpy = sandbox.stub(vscode.commands, 'executeCommand').resolves();
+ const provider = new MetadataDiffTreeDataProvider(context);
+ await provider.setDiffFiles([
+ { relativePath: 'a/b/file.txt', changes: 'Modified', type: 'modified', workspaceContent: 'one', storageContent: 'two' }
+ ] as any);
+ expect(provider.items.length).to.equal(1);
+ expect(execSpy.calledWith('setContext', 'microsoft.powerplatform.pages.metadataDiff.hasData', true)).to.be.true;
+ });
+
+ it("clearItems resets state and context", async () => {
+ const execSpy = sandbox.stub(vscode.commands, 'executeCommand').resolves();
+ const provider = new MetadataDiffTreeDataProvider(context);
+ await provider.setDiffFiles([
+ { relativePath: 'file.txt', changes: 'Modified', type: 'modified', workspaceContent: 'one', storageContent: 'two' }
+ ] as any);
+ expect(provider.items.length).to.equal(1);
+ provider.clearItems();
+ expect(provider.items.length).to.equal(0);
+ expect(execSpy.calledWith('setContext', 'microsoft.powerplatform.pages.metadataDiff.hasData', false)).to.be.true;
+ });
+});
diff --git a/src/common/utilities/PacAuthUtil.ts b/src/common/utilities/PacAuthUtil.ts
index 78305a5c4..1c5ad9878 100644
--- a/src/common/utilities/PacAuthUtil.ts
+++ b/src/common/utilities/PacAuthUtil.ts
@@ -10,22 +10,25 @@ import { AUTH_CREATE_FAILED, AUTH_CREATE_MESSAGE } from "../copilot/constants";
import { showInputBoxAndGetOrgUrl, showProgressWithNotification } from "./Utils";
- export async function createAuthProfileExp(pacWrapper: PacWrapper | undefined) {
- const userOrgUrl = await showInputBoxAndGetOrgUrl();
- if (!userOrgUrl) {
- return;
- }
+ export async function createAuthProfileExp(pacWrapper: PacWrapper | undefined, userOrgUrl = "") {
+ if (!userOrgUrl) {
+ userOrgUrl = await showInputBoxAndGetOrgUrl() ?? "";
+ }
- if (!pacWrapper) {
- vscode.window.showErrorMessage(AUTH_CREATE_FAILED);
- return;
- }
+ if (!userOrgUrl) {
+ return;
+ }
- const pacAuthCreateOutput = await showProgressWithNotification(vscode.l10n.t(AUTH_CREATE_MESSAGE), async () => { return await pacWrapper?.authCreateNewAuthProfileForOrg(userOrgUrl) });
- if (pacAuthCreateOutput && pacAuthCreateOutput.Status !== SUCCESS) {
- vscode.window.showErrorMessage(AUTH_CREATE_FAILED);
- return;
- }
+ if (!pacWrapper) {
+ vscode.window.showErrorMessage(AUTH_CREATE_FAILED);
+ return;
+ }
+
+ const pacAuthCreateOutput = await showProgressWithNotification(vscode.l10n.t(AUTH_CREATE_MESSAGE), async () => { return await pacWrapper?.authCreateNewAuthProfileForOrg(userOrgUrl) });
+ if (pacAuthCreateOutput && pacAuthCreateOutput.Status !== SUCCESS) {
+ vscode.window.showErrorMessage(AUTH_CREATE_FAILED);
+ return;
+ }
return pacAuthCreateOutput;
}