feat(vscode): regenerate local.settings.json, host.json, and workflow-designtime for source-controlled Logic App projects

apps/vs-code-designer/src/app/commands/createNewCodeProject/CodeProjectBase/CreateLogicAppWorkspace.ts

@@ -1,32 +1,21 @@
 import {
-  appKindSetting,
   artifactsDirectory,
   assetsFolderName,
   autoRuntimeDependenciesPathSettingKey,
-  azureWebJobsFeatureFlagsKey,
-  azureWebJobsStorageKey,
   defaultVersionRange,
   devContainerFolderName,
   extensionBundleId,
   extensionCommand,
   funcIgnoreFileName,
-  functionsInprocNet8Enabled,
-  functionsInprocNet8EnabledTrue,
   gitignoreFileName,
   hostFileName,
   libDirectory,
-  localEmulatorConnectionString,
   localSettingsFileName,
-  logicAppKind,
   lspDirectory,
-  multiLanguageWorkerSetting,
-  ProjectDirectoryPathKey,
   rulesDirectory,
   schemasDirectory,
   testsDirectoryName,
   vscodeFolderName,
-  workerRuntimeKey,
-  workflowCodefulEnabledKey,
   workflowFileName,
 } from '../../../../constants';
 import { localize } from '../../../../localize';
@@ -43,14 +32,9 @@ import { gitInit, isGitInstalled, isInsideRepo } from '../../../utils/git';
 import { writeFormattedJson } from '../../../utils/fs';
 import { getCodelessWorkflowTemplate } from '../../../utils/codeless/templates';
 import { CreateFunctionAppFiles } from './CreateFunctionAppFiles';
-import type {
-  IFunctionWizardContext,
-  IHostJsonV2,
-  ILocalSettingsJson,
-  IWebviewProjectContext,
-  StandardApp,
-} from '@microsoft/vscode-extension-logic-apps';
-import { WorkerRuntime, ProjectType, WorkflowType } from '@microsoft/vscode-extension-logic-apps';
+import type { IFunctionWizardContext, IHostJsonV2, IWebviewProjectContext, StandardApp } from '@microsoft/vscode-extension-logic-apps';
+import { ProjectType, WorkflowType } from '@microsoft/vscode-extension-logic-apps';
+import { getLocalSettingsSchema } from '../../../utils/appSettings/localSettings';
 import { createDevContainerContents, createLogicAppVsCodeContents } from './CreateLogicAppVSCodeContents';
 import { logicAppPackageProcessing, unzipLogicAppPackageIntoWorkspace } from '../../../utils/cloudToLocalUtils';
 import { isLogicAppProject } from '../../../utils/verifyIsProject';
@@ -213,24 +197,10 @@ export async function createLocalConfigurationFiles(
     '.debug',
     'workflow-designtime/',
   ];
-  const localSettingsJson: ILocalSettingsJson = {
-    IsEncrypted: false,
-    Values: {
-      [azureWebJobsStorageKey]: localEmulatorConnectionString,
-      [functionsInprocNet8Enabled]: functionsInprocNet8EnabledTrue,
-      [workerRuntimeKey]: WorkerRuntime.Dotnet,
-      [appKindSetting]: logicAppKind,
-      [ProjectDirectoryPathKey]: logicAppFolderPath,
-    },
-  };
+  const localSettingsJson = getLocalSettingsSchema(false, logicAppFolderPath, logicAppType);
 
   if (logicAppType !== ProjectType.logicApp) {
     funcignore.push('global.json');
-    localSettingsJson.Values[azureWebJobsFeatureFlagsKey] = multiLanguageWorkerSetting;
-  }
-
-  if (logicAppType === ProjectType.codeful) {
-    localSettingsJson.Values[workflowCodefulEnabledKey] = 'true';
   }
 
   const hostJsonPath: string = path.join(logicAppFolderPath, hostFileName);

apps/vs-code-designer/src/app/commands/createNewCodeProject/CodeProjectBase/__test__/CreateLogicAppWorkspace.test.ts

@@ -1308,6 +1308,13 @@ describe('createLocalConfigurationFiles', () => {
     workflowName: 'TestWorkflow',
   } as any;
 
+  const mockContextCodeful: IWebviewProjectContext = {
+    workspaceName: 'TestWorkspace',
+    logicAppName: 'TestLogicApp',
+    logicAppType: ProjectType.codeful,
+    workflowName: 'TestWorkflow',
+  } as any;
+
   const logicAppFolderPath = actualPath.join('test', 'workspace', 'TestLogicApp');
 
   beforeEach(() => {
@@ -1506,6 +1513,31 @@ describe('createLocalConfigurationFiles', () => {
     expect(Object.keys(localSettingsData.Values)).toHaveLength(6);
   });
 
+  it('should create local.settings.json with exact required values for codeful projects', async () => {
+    await CreateLogicAppWorkspaceModule.createLocalConfigurationFiles(mockContextCodeful, logicAppFolderPath);
+
+    const localSettingsCall = vi
+      .mocked(fsUtils.writeFormattedJson)
+      .mock.calls.find((call) => call[0].toString().includes('local.settings.json'));
+    expect(localSettingsCall).toBeDefined();
+    const localSettingsData = localSettingsCall![1] as any;
+
+    // Codeful is not a plain logic app (so it gets the multi-language worker flag) and additionally
+    // gets the codeful-enabled flag.
+    expect(localSettingsData.Values).toEqual({
+      AzureWebJobsStorage: 'UseDevelopmentStorage=true',
+      FUNCTIONS_INPROC_NET8_ENABLED: '1',
+      FUNCTIONS_WORKER_RUNTIME: 'dotnet',
+      APP_KIND: 'workflowapp',
+      ProjectDirectoryPath: path.join('test', 'workspace', 'TestLogicApp'),
+      AzureWebJobsFeatureFlags: 'EnableMultiLanguageWorker',
+      WORKFLOW_CODEFUL_ENABLED: 'true',
+    });
+
+    // Verify exactly 7 properties exist (5 standard + feature flag + codeful-enabled).
+    expect(Object.keys(localSettingsData.Values)).toHaveLength(7);
+  });
+
   it('should include extension bundle configuration in host.json', async () => {
     await CreateLogicAppWorkspaceModule.createLocalConfigurationFiles(mockContext, logicAppFolderPath);
 

apps/vs-code-designer/src/app/utils/__test__/verifyIsProject.test.ts

@@ -1,9 +1,9 @@
-import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
+import { describe, it, expect, vi, afterEach } from 'vitest';
 import type { WorkspaceFolder } from 'vscode';
 import * as fse from 'fs-extra';
 import * as path from 'path';
 import * as verifyIsProject from '../verifyIsProject';
-import { hostFileName, workflowFileName } from '../../../constants';
+import { hostFileName, localSettingsFileName, workflowFileName } from '../../../constants';
 
 describe('tryGetAllLogicAppProjectRoots', () => {
   const testWorkspaceFolderPath = path.join('test', 'workspace', 'LogicApp1');
@@ -102,7 +102,40 @@ describe('tryGetAllLogicAppProjectRoots', () => {
       return [];
     });
     vi.spyOn(fse, 'readFile').mockImplementation(async (filePath: fse.PathLike) => {
+      // A workflow.json that is not a Microsoft.Logic workflow definition is not a Logic Apps signal.
       if (filePath === path.join(testWorkspaceFolderPath, 'sub1', workflowFileName)) {
+        return JSON.stringify({ definition: { $schema: 'https://example.com/not-a-logic-workflow.json#' } });
+      }
+      return '';
+    });
+
+    const result = await verifyIsProject.tryGetAllLogicAppProjectRoots(testWorkspaceFolder);
+    expect(result).toEqual([]);
+  });
+});
+
+describe('isLogicAppProject', () => {
+  const projectPath = path.join('test', 'LogicApp');
+
+  afterEach(() => {
+    vi.clearAllMocks();
+  });
+
+  it('returns false when the folder does not exist', async () => {
+    vi.spyOn(fse, 'pathExists').mockResolvedValue(false);
+    expect(await verifyIsProject.isLogicAppProject(projectPath)).toBe(false);
+  });
+
+  it('detects a codeless project via workflow.json even when host.json is missing', async () => {
+    const workflowJsonPath = path.join(projectPath, 'stateful1', workflowFileName);
+    // No host.json, no local.settings.json, no .csproj on disk — only the workflow folder exists.
+    vi.spyOn(fse, 'pathExists').mockImplementation(async (p: fse.PathLike) => {
+      const s = String(p);
+      return s === projectPath || s === workflowJsonPath;
+    });
+    vi.spyOn(fse, 'readdir').mockImplementation(async (p: fse.PathLike) => (String(p) === projectPath ? ['stateful1'] : []));
+    vi.spyOn(fse, 'readFile').mockImplementation(async (p: fse.PathLike) => {
+      if (String(p) === workflowJsonPath) {
         return JSON.stringify({
           definition: {
             $schema: 'https://schema.management.azure.com/providers/Microsoft.Logic/schemas/2016-06-01/workflowdefinition.json#',
@@ -112,7 +145,109 @@ describe('tryGetAllLogicAppProjectRoots', () => {
       return '';
     });
 
-    const result = await verifyIsProject.tryGetAllLogicAppProjectRoots(testWorkspaceFolder);
-    expect(result).toEqual([]);
+    expect(await verifyIsProject.isLogicAppProject(projectPath)).toBe(true);
+  });
+
+  it('detects a codeless project even when a present host.json is corrupted', async () => {
+    const workflowJsonPath = path.join(projectPath, 'stateful1', workflowFileName);
+    vi.spyOn(fse, 'pathExists').mockImplementation(async (p: fse.PathLike) => {
+      const s = String(p);
+      return s === projectPath || s === path.join(projectPath, hostFileName) || s === workflowJsonPath;
+    });
+    vi.spyOn(fse, 'readdir').mockImplementation(async (p: fse.PathLike) => (String(p) === projectPath ? [hostFileName, 'stateful1'] : []));
+    vi.spyOn(fse, 'readFile').mockImplementation(async (p: fse.PathLike) => {
+      if (String(p) === path.join(projectPath, hostFileName)) {
+        return 'this is not valid json {';
+      }
+      if (String(p) === workflowJsonPath) {
+        return JSON.stringify({
+          definition: {
+            $schema: 'https://schema.management.azure.com/providers/Microsoft.Logic/schemas/2016-06-01/workflowdefinition.json#',
+          },
+        });
+      }
+      return '';
+    });
+
+    expect(await verifyIsProject.isLogicAppProject(projectPath)).toBe(true);
+  });
+
+  it('detects a codeful project via its .csproj SDK reference regardless of the workflow .cs file name', async () => {
+    const csprojPath = path.join(projectPath, 'MyLogicApp.csproj');
+    // A codeful project is a .NET 8 project referencing the Logic Apps SDK; the workflow C# file
+    // can be named anything (here, MyCustomWorkflow.cs — not workflow.cs). Detection is structural
+    // (via the .csproj), so a literal workflow.cs is never required.
+    vi.spyOn(fse, 'statSync').mockReturnValue({ isDirectory: () => true } as unknown as fse.Stats);
+    vi.spyOn(fse, 'pathExists').mockImplementation(async (p: fse.PathLike) => String(p) === projectPath);
+    vi.spyOn(fse, 'readdir').mockImplementation(async (p: fse.PathLike) =>
+      String(p) === projectPath ? ['MyLogicApp.csproj', 'MyCustomWorkflow.cs', 'Program.cs'] : []
+    );
+    vi.spyOn(fse, 'readFile').mockImplementation(async (p: fse.PathLike) => {
+      if (String(p) === csprojPath) {
+        return [
+          '<Project Sdk="Microsoft.NET.Sdk">',
+          '  <PropertyGroup><TargetFramework>net8</TargetFramework></PropertyGroup>',
+          '  <ItemGroup><PackageReference Include="Microsoft.Azure.Workflows.Sdk" Version="1.0.0-preview.1" /></ItemGroup>',
+          '</Project>',
+        ].join('\n');
+      }
+      return '';
+    });
+
+    expect(await verifyIsProject.isLogicAppProject(projectPath)).toBe(true);
+  });
+
+  it('does not tag a plain Functions project (host.json present, no workflow signal)', async () => {
+    const localSettingsPath = path.join(projectPath, localSettingsFileName);
+    vi.spyOn(fse, 'pathExists').mockImplementation(async (p: fse.PathLike) => {
+      const s = String(p);
+      return s === projectPath || s === path.join(projectPath, hostFileName) || s === localSettingsPath;
+    });
+    vi.spyOn(fse, 'readdir').mockImplementation(async (p: fse.PathLike) =>
+      String(p) === projectPath ? [hostFileName, localSettingsFileName, 'MyHttpFunction'] : []
+    );
+    vi.spyOn(fse, 'readFile').mockImplementation(async (p: fse.PathLike) => {
+      if (String(p) === localSettingsPath) {
+        return JSON.stringify({ Values: { FUNCTIONS_WORKER_RUNTIME: 'dotnet' } });
+      }
+      return '';
+    });
+
+    expect(await verifyIsProject.isLogicAppProject(projectPath)).toBe(false);
+  });
+
+  it('does not tag a folder that only has the codeful workspace setting but no .csproj', async () => {
+    // WORKFLOW_CODEFUL_ENABLED lives in the gitignored local.settings.json and is no longer a
+    // detection signal — without the authoritative .csproj SDK reference the folder is not a project.
+    const localSettingsPath = path.join(projectPath, localSettingsFileName);
+    vi.spyOn(fse, 'pathExists').mockImplementation(async (p: fse.PathLike) => {
+      const s = String(p);
+      return s === projectPath || s === localSettingsPath;
+    });
+    vi.spyOn(fse, 'readdir').mockImplementation(async (p: fse.PathLike) =>
+      String(p) === projectPath ? [localSettingsFileName, 'Program.cs'] : []
+    );
+    vi.spyOn(fse, 'readFile').mockImplementation(async (p: fse.PathLike) => {
+      if (String(p) === localSettingsPath) {
+        return JSON.stringify({ Values: { WORKFLOW_CODEFUL_ENABLED: 'true' } });
+      }
+      return '';
+    });
+
+    expect(await verifyIsProject.isLogicAppProject(projectPath)).toBe(false);
+  });
+
+  it('does not tag a folder whose workflow.json is not a Microsoft.Logic workflow', async () => {
+    const workflowJsonPath = path.join(projectPath, 'wf', workflowFileName);
+    vi.spyOn(fse, 'pathExists').mockImplementation(async (p: fse.PathLike) => {
+      const s = String(p);
+      return s === projectPath || s === workflowJsonPath;
+    });
+    vi.spyOn(fse, 'readdir').mockImplementation(async (p: fse.PathLike) => (String(p) === projectPath ? ['wf'] : []));
+    vi.spyOn(fse, 'readFile').mockImplementation(async (p: fse.PathLike) =>
+      String(p) === workflowJsonPath ? JSON.stringify({ definition: { $schema: 'https://example.com/not-logic.json#' } }) : ''
+    );
+
+    expect(await verifyIsProject.isLogicAppProject(projectPath)).toBe(false);
   });
 });