fix(vscode): Fix multiple extension commands/events

Localize/lang/strings.json

@@ -1142,6 +1142,7 @@
   "KY5eNe": "On",
   "KYX5Do": "Underline (⌘U)",
   "KZOa5l": "Cancel",
+  "Karw2Q": "Workspace location cannot be inside the currently open project folder. Choose the current folder or a location outside it.",
   "Kasmd1": "Go to workflow",
   "Kb5u9F": "About tab",
   "KlDW+5": "(UTC+02:00) Beirut",
@@ -3099,6 +3100,7 @@
   "_KY5eNe.comment": "Label for the enabled switch",
   "_KYX5Do.comment": "Command for underline text for Mac users",
   "_KZOa5l.comment": "Label for cancel button",
+  "_Karw2Q.comment": "Workspace location is a descendant of the currently open folder error text",
   "_Kasmd1.comment": "Label to indicate go to the workflow",
   "_Kb5u9F.comment": "An accessibility label that describes the about tab",
   "_KlDW+5.comment": "Time zone value ",

apps/vs-code-designer/src/app/commands/__test__/ensureWorkspace.test.ts

@@ -1,5 +1,5 @@
 import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
-import { ensureWorkspace } from '../ensureWorkspace';
+import { ensureWorkspace, createWorkspaceFile } from '../ensureWorkspace';
 import * as vscode from 'vscode';
 import * as workspaceUtils from '../../utils/workspace';
 import * as verifyProject from '../../utils/verifyIsProject';
@@ -35,6 +35,18 @@ vi.mock('../shared/workspaceWebviewCommandHandler', () => ({
   createWorkspaceWebviewCommandHandler: vi.fn(),
 }));
 
+vi.mock('fs-extra', async (importOriginal) => {
+  const original = await importOriginal<typeof fse>();
+  return {
+    ...original,
+    writeJson: vi.fn(),
+    copy: vi.fn(),
+    ensureDir: vi.fn(),
+    readdir: vi.fn(),
+    pathExists: vi.fn(),
+  };
+});
+
 describe('ensureWorkspace', () => {
   const testWorkspaceName = 'TestWorkspace';
   const testWorkspaceFolder: vscode.WorkspaceFolder = {
@@ -133,13 +145,13 @@ describe('ensureWorkspace', () => {
     vi.spyOn(verifyProject, 'getFirstLogicAppProjectRoot').mockImplementation(async (f: vscode.WorkspaceFolder | string | undefined) => {
       return f === testLogicAppChildFolder ? testLogicAppChildFolder : undefined;
     });
-    vi.spyOn(fse, 'readdir').mockImplementation(async (p: fse.PathLike) => {
+    vi.mocked(fse.readdir).mockImplementation(async (p: fse.PathLike) => {
       if (p === testWorkspaceFolder.uri.fsPath) {
-        return [new MockDirent(testLogicAppName, true)];
+        return [new MockDirent(testLogicAppName, true)] as any;
       }
       return [];
     });
-    vi.spyOn(fse, 'pathExists').mockImplementation(async (p: fse.PathLike) => {
+    vi.mocked(fse.pathExists).mockImplementation(async (p: fse.PathLike) => {
       return p === testWorkspaceFolder.uri.fsPath || p === testLogicAppChildFolder;
     });
     const isLogicAppProjectInRootSpy = vi
@@ -209,3 +221,114 @@ describe('ensureWorkspace', () => {
     expect(result).toBe(true);
   });
 });
+
+describe('createWorkspaceFile', () => {
+  let context: any;
+
+  beforeEach(() => {
+    context = {
+      telemetry: {
+        properties: {},
+        measurements: {},
+      },
+    };
+    vi.spyOn(funcCoreTools, 'addLocalFuncTelemetry').mockImplementation(() => {});
+    vi.mocked(fse.writeJson).mockResolvedValue(undefined);
+    vi.mocked(fse.copy).mockResolvedValue(undefined);
+    vi.mocked(fse.ensureDir).mockResolvedValue(undefined);
+  });
+
+  afterEach(() => {
+    vi.resetAllMocks();
+  });
+
+  it('in-place Logic App root: writes .code-workspace without copying', async () => {
+    const projectPath = path.resolve('/users/dev/MyLogicApp');
+    (vscode.workspace as any).workspaceFolders = [{ name: 'MyLogicApp', uri: { fsPath: projectPath } as vscode.Uri, index: 0 }];
+    vi.spyOn(verifyProject, 'isLogicAppProject').mockResolvedValue(true);
+    const executeCommandSpy = vi.spyOn(vscode.commands, 'executeCommand').mockResolvedValue(undefined);
+
+    await createWorkspaceFile(context, {
+      workspaceProjectPath: { fsPath: path.dirname(projectPath), path: path.dirname(projectPath) },
+      workspaceName: 'MyLogicApp',
+    });
+
+    expect(fse.copy).not.toHaveBeenCalled();
+    expect(fse.writeJson).toHaveBeenCalledWith(
+      path.join(projectPath, 'MyLogicApp.code-workspace'),
+      { folders: [{ name: 'MyLogicApp', path: '.' }] },
+      { spaces: 2 }
+    );
+    expect(executeCommandSpy).toHaveBeenCalledWith(
+      vscodeCommand.openFolder,
+      expect.objectContaining({ fsPath: path.join(projectPath, 'MyLogicApp.code-workspace') }),
+      true
+    );
+  });
+
+  it('in-place container with child directories: lists children without copying', async () => {
+    const containerPath = path.resolve('/users/dev/workspace-root');
+    (vscode.workspace as any).workspaceFolders = [{ name: 'workspace-root', uri: { fsPath: containerPath } as vscode.Uri, index: 0 }];
+    vi.spyOn(verifyProject, 'isLogicAppProject').mockResolvedValue(false);
+    vi.mocked(fse.readdir).mockResolvedValue([
+      new MockDirent('app1', true),
+      new MockDirent('app2', true),
+      new MockDirent('readme.md', false),
+    ] as any);
+    const executeCommandSpy = vi.spyOn(vscode.commands, 'executeCommand').mockResolvedValue(undefined);
+
+    await createWorkspaceFile(context, {
+      workspaceProjectPath: { fsPath: path.dirname(containerPath), path: path.dirname(containerPath) },
+      workspaceName: 'workspace-root',
+    });
+
+    expect(fse.copy).not.toHaveBeenCalled();
+    expect(fse.writeJson).toHaveBeenCalledWith(
+      path.join(containerPath, 'workspace-root.code-workspace'),
+      {
+        folders: [
+          { name: 'app1', path: './app1' },
+          { name: 'app2', path: './app2' },
+        ],
+      },
+      { spaces: 2 }
+    );
+    expect(executeCommandSpy).toHaveBeenCalled();
+  });
+
+  it('external copy: copies project to new location', async () => {
+    const currentPath = path.resolve('/users/dev/MyLogicApp');
+    const externalParent = path.resolve('/users/workspaces');
+    const externalDest = path.join(externalParent, 'NewWorkspace');
+
+    (vscode.workspace as any).workspaceFolders = [{ name: 'MyLogicApp', uri: { fsPath: currentPath } as vscode.Uri, index: 0 }];
+    vi.spyOn(verifyProject, 'isLogicAppProject').mockResolvedValue(true);
+    const executeCommandSpy = vi.spyOn(vscode.commands, 'executeCommand').mockResolvedValue(undefined);
+
+    await createWorkspaceFile(context, {
+      workspaceProjectPath: { fsPath: externalParent, path: externalParent },
+      workspaceName: 'NewWorkspace',
+    });
+
+    expect(fse.ensureDir).toHaveBeenCalledWith(externalDest);
+    expect(fse.copy).toHaveBeenCalledWith(currentPath, path.join(externalDest, 'MyLogicApp'));
+    expect(fse.writeJson).toHaveBeenCalledWith(
+      path.join(externalDest, 'NewWorkspace.code-workspace'),
+      { folders: [{ name: 'MyLogicApp', path: './MyLogicApp' }] },
+      { spaces: 2 }
+    );
+    expect(executeCommandSpy).toHaveBeenCalled();
+  });
+
+  it('descendant rejection: throws when workspace target is inside current folder', async () => {
+    const currentPath = path.resolve('/users/dev/MyLogicApp');
+    (vscode.workspace as any).workspaceFolders = [{ name: 'MyLogicApp', uri: { fsPath: currentPath } as vscode.Uri, index: 0 }];
+
+    await expect(
+      createWorkspaceFile(context, {
+        workspaceProjectPath: { fsPath: currentPath, path: currentPath },
+        workspaceName: 'subdir',
+      })
+    ).rejects.toThrow(/inside the currently open folder/);
+  });
+});

apps/vs-code-designer/src/app/commands/__test__/pickCustomCodeWorkerProcess.test.ts

@@ -1,9 +1,6 @@
 import { describe, it, expect, beforeEach, afterEach, vi } from 'vitest';
 import * as vscode from 'vscode';
-import {
-  pickCustomCodeNetHostProcessInternal,
-  pickCustomCodeWorkerChildProcess,
-} from '../pickCustomCodeWorkerProcess';
+import { pickCustomCodeNetHostProcessInternal, pickCustomCodeWorkerChildProcess } from '../pickCustomCodeWorkerProcess';
 import * as validatePreDebug from '../../debug/validatePreDebug';
 import { IRunningFuncTask, runningFuncTaskMap } from '../../utils/funcCoreTools/funcHostTask';
 import * as pickFuncProcessModule from '../pickFuncProcess';
@@ -21,6 +18,14 @@ vi.mock('vscode', () => ({
   },
 }));
 
+vi.mock('../../utils/delay', () => ({
+  delay: vi.fn((ms: number) => {
+    // Advance fake timers so the polling loop's Date.now() check terminates
+    vi.advanceTimersByTime(ms);
+    return Promise.resolve();
+  }),
+}));
+
 describe('pickCustomCodeNetHostProcessInternal', () => {
   const testLogicAppName = 'LogicApp';
   const testLogicAppPath = path.join('path', 'to', testLogicAppName);
@@ -31,15 +36,17 @@ describe('pickCustomCodeNetHostProcessInternal', () => {
     name: testLogicAppName,
     index: 0,
   };
-  const testActionContext = {
-    telemetry: { properties: {} },
-  } as IActionContext;
+  let testActionContext: IActionContext;
   const testFuncTask: IRunningFuncTask = {
     startTime: Date.now(),
     processId: Number(testFuncPid),
   };
 
   beforeEach(() => {
+    vi.useFakeTimers();
+    testActionContext = {
+      telemetry: { properties: {}, measurements: {} },
+    } as IActionContext;
     (vscode.workspace as any).workspaceFolders = [testLogicAppWorkspaceFolder];
 
     vi.spyOn(validatePreDebug, 'getMatchingWorkspaceFolder').mockReturnValue(testLogicAppWorkspaceFolder);
@@ -49,15 +56,17 @@ describe('pickCustomCodeNetHostProcessInternal', () => {
   });
 
   afterEach(() => {
+    vi.useRealTimers();
     vi.restoreAllMocks();
     runningFuncTaskMap.clear();
   });
 
-  it('should return undefined when no child dotnet process exists on the logic app functions host', async () => {
+  it('should throw when no child dotnet process exists on the logic app functions host after polling', async () => {
     runningFuncTaskMap.set(testLogicAppWorkspaceFolder, testFuncTask);
-    await expect(
-      pickCustomCodeNetHostProcessInternal(testActionContext, testLogicAppWorkspaceFolder, testLogicAppPath)
-    ).resolves.toBeUndefined();
+    await expect(pickCustomCodeNetHostProcessInternal(testActionContext, testLogicAppWorkspaceFolder, testLogicAppPath)).rejects.toThrow(
+      /Failed to find the .NET host child process/
+    );
+    expect(testActionContext.telemetry.properties.result).toBe('Failed');
     expect(testActionContext.telemetry.properties.lastStep).toBe('pickNetHostChildProcess');
   });
 

apps/vs-code-designer/src/app/commands/binaries/__test__/validateAndInstallBinaries.test.ts

@@ -3,7 +3,7 @@ import { beforeEach, describe, expect, it, type Mock, vi } from 'vitest';
 import { defaultDependencyPathValue } from '../../../../constants';
 import { ext } from '../../../../extensionVariables';
 import { getDependencyTimeout, ensureRuntimeDependenciesDir } from '../../../utils/binaries';
-import { ensureExtensionBundleHealthy, getDependenciesVersion } from '../../../utils/bundleFeed';
+import { ensureExtensionBundleHealthy, getBundleDependencyFeed } from '../../../utils/bundleFeed';
 import { recordDependencyUpdateCheck, shouldCheckForDependencyUpdates } from '../../../state/dependencies';
 import { setDotNetCommand } from '../../../utils/dotnet/dotnet';
 import { setFunctionsCommand } from '../../../utils/funcCoreTools/funcVersion';
@@ -28,7 +28,7 @@ vi.mock('../../../utils/binaries', () => ({
 }));
 
 vi.mock('../../../utils/bundleFeed', () => ({
-  getDependenciesVersion: vi.fn(),
+  getBundleDependencyFeed: vi.fn(),
   ensureExtensionBundleHealthy: vi.fn().mockResolvedValue(undefined),
 }));
 
@@ -106,7 +106,7 @@ describe('validateAndInstallBinaries', () => {
     (shouldRequireStrictDependencyValidation as Mock).mockReturnValue(false);
     (shouldCheckForDependencyUpdates as Mock).mockReturnValue(true);
     (recordDependencyUpdateCheck as Mock).mockResolvedValue(undefined);
-    (getDependenciesVersion as Mock).mockResolvedValue({
+    (getBundleDependencyFeed as Mock).mockResolvedValue({
       nodejs: '18.0.0',
       funcCoreTools: '4.0.0',
       dotnetVersions: '8.0.100',

apps/vs-code-designer/src/app/commands/binaries/validateAndInstallBinaries.ts

@@ -5,7 +5,7 @@
 import { ext } from '../../../extensionVariables';
 import { localize } from '../../../localize';
 import { ensureRuntimeDependenciesDir, getDependencyTimeout } from '../../utils/binaries';
-import { getDependenciesVersion, ensureExtensionBundleHealthy } from '../../utils/bundleFeed';
+import { ensureExtensionBundleHealthy, getBundleDependencyFeed } from '../../utils/bundleFeed';
 import { recordDependencyUpdateCheck, shouldCheckForDependencyUpdates } from '../../state/dependencies';
 import { setDotNetCommand } from '../../utils/dotnet/dotnet';
 import { setFunctionsCommand } from '../../utils/funcCoreTools/funcVersion';
@@ -17,7 +17,7 @@ import { validateDotNetIsLatest } from '../dotnet/validateDotNetIsLatest';
 import { validateFuncCoreToolsIsLatest } from '../funcCoreTools/validateFuncCoreToolsIsLatest';
 import { validateNodeJsIsLatest } from '../nodeJs/validateNodeJsIsLatest';
 import { callWithTelemetryAndErrorHandling, type IActionContext } from '@microsoft/vscode-azext-utils';
-import type { IBundleDependencyFeed } from '@microsoft/vscode-extension-logic-apps';
+import type { IRuntimeDependencyVersions } from '@microsoft/vscode-extension-logic-apps';
 import * as vscode from 'vscode';
 
 export async function validateAndInstallBinaries(context: IActionContext) {
@@ -50,11 +50,11 @@ export async function validateAndInstallBinaries(context: IActionContext) {
       const performedUpdateCheck = shouldCheckForDependencyUpdates();
       context.telemetry.properties.performedDependencyUpdateCheck = `${performedUpdateCheck}`;
 
-      context.telemetry.properties.lastStep = 'getDependenciesVersion';
+      context.telemetry.properties.lastStep = 'getBundleDependencyFeed';
       progress.report({ increment: 10, message: 'Get dependency version from CDN' });
-      let dependenciesVersions: IBundleDependencyFeed;
+      let dependenciesVersions: IRuntimeDependencyVersions;
       try {
-        dependenciesVersions = await getDependenciesVersion(context);
+        dependenciesVersions = await getBundleDependencyFeed(context);
         context.telemetry.properties.dependenciesVersions = JSON.stringify(dependenciesVersions);
       } catch (error) {
         // Unable to get dependency.json, will default to fallback versions

apps/vs-code-designer/src/app/commands/buildCustomCodeFunctionsProject.ts

@@ -9,6 +9,7 @@ import { getWorkspaceRoot } from '../utils/workspace';
 import { isCustomCodeFunctionsProject, tryGetLogicAppCustomCodeFunctionsProjects } from '../utils/customCodeUtils';
 import * as vscode from 'vscode';
 import { isNullOrUndefined } from '@microsoft/logic-apps-shared';
+import { isPathEqual } from '../utils/fs';
 
 /**
  * Builds a custom code functions project if exists.
@@ -65,7 +66,7 @@ async function buildCustomCodeProject(functionsProjectPath: string): Promise<voi
   const tasks: vscode.Task[] = await vscode.tasks.fetchTasks();
   const buildTask = tasks.find((task) => {
     const currTaskPath = (task.scope as vscode.WorkspaceFolder)?.uri.fsPath;
-    return task.name === 'build' && currTaskPath === functionsProjectPath;
+    return task.name === 'build' && !!currTaskPath && isPathEqual(currTaskPath, functionsProjectPath);
   });
 
   if (!buildTask) {
@@ -75,7 +76,8 @@ async function buildCustomCodeProject(functionsProjectPath: string): Promise<voi
   return new Promise<void>((resolve, reject) => {
     const disposable: vscode.Disposable = vscode.tasks.onDidEndTaskProcess((e) => {
       const isMatchingTask =
-        (e.execution.task.scope as vscode.WorkspaceFolder)?.uri.fsPath === functionsProjectPath && e.execution.task.name === buildTask.name;
+        isPathEqual((e.execution.task.scope as vscode.WorkspaceFolder)?.uri.fsPath ?? '', functionsProjectPath) &&
+        e.execution.task.name === buildTask.name;
 
       if (isMatchingTask) {
         disposable.dispose();

apps/vs-code-designer/src/app/commands/createCustomCodeFunction/createCustomCodeFunction.ts

@@ -107,6 +107,5 @@ export async function createCustomCodeFunction(context: IActionContext, folderPa
       context.telemetry.properties.errorMessage = err.message;
       throw err;
     }
-    context.telemetry.properties.result = 'Succeeded';
   }
 }

apps/vs-code-designer/src/app/commands/dataMapper/dataMapper.ts

@@ -138,8 +138,6 @@ export async function loadDataMapFile(context: IActionContext, uri: Uri): Promis
           if (fileUris && fileUris.length > 0) {
             // Copy the schema file they selected to the Schemas folder (can safely continue map definition loading)
             await fs.copyFile(fileUris[0].fsPath, schemaPath);
-            context.telemetry.properties.result = 'Succeeded';
-
             return true;
           }
         }

apps/vs-code-designer/src/app/commands/debugLogicApp.ts

@@ -10,7 +10,6 @@ import { localize } from '../../localize';
 import { ext } from '../../extensionVariables';
 import { tryGetLogicAppProjectRoot } from '../utils/verifyIsProject';
 import { pickCustomCodeNetFxWorkerProcessInternal, pickCustomCodeNetHostProcessInternal } from './pickCustomCodeWorkerProcess';
-import { extensionCommand } from '../../constants';
 
 export async function debugLogicApp(
   context: IActionContext,
@@ -142,5 +141,4 @@ export async function debugLogicApp(
       )
     );
   }
-  context.telemetry.properties.result = 'Succeeded';
 }

apps/vs-code-designer/src/app/commands/deploy/deploy.ts

@@ -101,16 +101,16 @@ async function deploy(
   addLocalFuncTelemetry(context);
 
   let deployProjectPathForWorkflowApp: string | undefined;
-  const settingsToExclude: string[] = [
+  const settingsToExclude: (RegExp | string)[] = [
     webhookRedirectHostUri,
     azureWebJobsStorageKey,
     ProjectDirectoryPathKey,
     workflowAuthenticationMethodKey,
     'REMOTEDEBUGGINGVERSION',
-    // Local-debug-only: absolute path to the local Node.js binary used by the inline-code
-    // language worker. Deploying it points the cloud worker at a non-existent local path,
-    // which hangs "Execute JavaScript Code" actions in a Running state indefinitely.
     inlineCodeNodeExecutablePathKey,
+    /^WEBSITE_/,
+    /^FUNCTIONS_RUNTIME/,
+    'ScmType',
   ];
 
   context.telemetry.properties.lastStep = 'getDeployFsPath';
@@ -410,7 +410,7 @@ async function managedApiConnectionsExists(workspaceFolder: WorkspaceFolder): Pr
 async function getProjectPathToDeploy(
   node: SlotTreeItem,
   workspaceFolder: WorkspaceFolder,
-  settingsToExclude: string[],
+  settingsToExclude: (RegExp | string)[],
   originalDeployFsPath: string,
   identityWizardContext: IIdentityWizardContext,
   actionContext: IActionContext