refactor(fx-core): delegate manifest macro resolution to app-manifest

Rewrite envFunctionUtils as a thin adapter over the resolver primitives
now provided by @microsoft/app-manifest (reached transitively via
@microsoft/teamsfx-api). expandVariableWithFunction keeps its signature
and telemetry loop, delegating each call to resolveManifestFunctionCall
and mapping the resolver's plain errors to localized UserError and
fx-core FileNotFoundError via toFxError.

Update the affected tests to drive resolution through real temp files
instead of fs mocks, since file reads now happen inside app-manifest
using node:fs/promises rather than the previously mocked fs-extra layer.

Author: iclanton

packages/fx-core/src/component/utils/envFunctionUtils.ts

@@ -8,12 +8,18 @@ import {
   Result,
   UserError,
   UserErrorOptions,
+  // Host-agnostic manifest-template resolution, extracted into @microsoft/app-manifest
+  // and re-exported by @microsoft/teamsfx-api. fx-core stays the home for telemetry,
+  // localized messages, and FxError mapping; the resolution logic lives one layer down.
+  ManifestType,
+  resolveManifestFunctionCall,
+  UnsupportedFileFormatError as ManifestUnsupportedFileFormatError,
+  InvalidFunctionError as ManifestInvalidFunctionError,
+  InvalidFunctionParameterError as ManifestInvalidFunctionParameterError,
+  ReadFileError as ManifestReadFileError,
+  FileNotFoundError as ManifestFileNotFoundError,
 } from "@microsoft/teamsfx-api";
-import path from "path";
-import fs from "fs-extra";
-import stripBom from "strip-bom";
 import { FileNotFoundError } from "../../error";
-import { expandEnvironmentVariable } from "./common";
 import { getLocalizedString } from "../../common/localizeUtils";
 import { DriverContext } from "../driver/interface/commonArgs";
 
@@ -26,12 +32,40 @@ enum TelemetryPropertyKey {
   functionCount = "function-count",
 }
 
-export enum ManifestType {
-  TeamsManifest = "teams-manifest",
-  PluginManifest = "plugin-manifest",
-  DeclarativeCopilotManifest = "declarative-copilot-manifest",
-  ApiSpec = "api-spec",
-  EmbeddedKnowledgeFile = "embedded-knowledge-file",
+// Re-exported for existing importers (ManifestUtils, PluginManifestUtils, utils, createAppPackage).
+export { ManifestType };
+
+// Map a plain error thrown by @microsoft/app-manifest's resolver to the localized
+// FxError surface fx-core drivers expect, emitting the same diagnostic logs as before.
+function toFxError(e: unknown, ctx: DriverContext): FxError {
+  if (e instanceof ManifestUnsupportedFileFormatError) {
+    ctx.logProvider.error(
+      getLocalizedString("core.envFunc.unsupportedFile.errorLog", e.filePath, "txt")
+    );
+    return new UnsupportedFileFormatError(ctx.platform);
+  }
+  if (e instanceof ManifestInvalidFunctionError) {
+    ctx.logProvider.error(
+      getLocalizedString("core.envFunc.unsupportedFunction.errorLog", e.token, "file")
+    );
+    return new InvalidFunctionError(ctx.platform);
+  }
+  if (e instanceof ManifestInvalidFunctionParameterError) {
+    ctx.logProvider.error(
+      getLocalizedString("core.envFunc.invalidFunctionParameter.errorLog", e.token, "file")
+    );
+    return new InvalidFunctionParameter(ctx.platform);
+  }
+  if (e instanceof ManifestReadFileError) {
+    ctx.logProvider.error(
+      getLocalizedString("core.envFunc.readFile.errorLog", e.filePath, e.cause?.toString())
+    );
+    return new ReadFileError(ctx.platform, e.filePath);
+  }
+  if (e instanceof ManifestFileNotFoundError) {
+    return new FileNotFoundError(source, e.filePath);
+  }
+  throw e;
 }
 
 export async function expandVariableWithFunction(
@@ -50,16 +84,12 @@ export async function expandVariableWithFunction(
   }
   let count = 0;
   for (const placeholder of matches) {
-    const processedRes = await processFunction(
-      placeholder.slice(2, -1).trim(),
-      ctx,
-      envs,
-      fromPath
-    );
-    if (processedRes.isErr()) {
-      return err(processedRes.error);
+    let value: string;
+    try {
+      value = await resolveManifestFunctionCall(placeholder.slice(2, -1).trim(), envs, fromPath);
+    } catch (e) {
+      return err(toFxError(e, ctx));
     }
-    let value = processedRes.value;
     if (isJson && value) {
       value = JSON.stringify(value).slice(1, -1);
     }
@@ -78,95 +108,6 @@ export async function expandVariableWithFunction(
   return ok(content);
 }
 
-async function processFunction(
-  content: string,
-  ctx: DriverContext,
-  envs: { [key in string]: string } | undefined,
-  path: string
-): Promise<Result<string, FxError>> {
-  const firstTrimmedContent = content.trim();
-  if (!firstTrimmedContent.startsWith("file(") || !firstTrimmedContent.endsWith(")")) {
-    ctx.logProvider.error(
-      getLocalizedString("core.envFunc.unsupportedFunction.errorLog", firstTrimmedContent, "file")
-    );
-    return err(new InvalidFunctionError(ctx.platform));
-  }
-
-  // file()
-  const trimmedParameter = content.slice(5, -1).trim();
-  if (trimmedParameter[0] === "'" && trimmedParameter[trimmedParameter.length - 1] === "'") {
-    // static string as function parameter
-    const res = await readFileContent(
-      trimmedParameter.substring(1, trimmedParameter.length - 1),
-      ctx,
-      envs,
-      path
-    );
-    return res;
-  } else if (trimmedParameter.startsWith("${{") && trimmedParameter.endsWith("}}")) {
-    // env variable inside
-    const resolvedParameter = expandEnvironmentVariable(trimmedParameter, envs);
-
-    const res = readFileContent(resolvedParameter, ctx, envs, path);
-    return res;
-  } else if (trimmedParameter.startsWith("file(") && trimmedParameter.endsWith(")")) {
-    // nested function inside
-    const processsedRes = await processFunction(trimmedParameter, ctx, envs, path);
-
-    if (processsedRes.isErr()) {
-      return err(processsedRes.error);
-    }
-
-    const readFileRes = await readFileContent(processsedRes.value, ctx, envs, path);
-    return readFileRes;
-  } else {
-    // invalid content inside function
-    ctx.logProvider.error(
-      getLocalizedString("core.envFunc.invalidFunctionParameter.errorLog", trimmedParameter, "file")
-    );
-    return err(new InvalidFunctionParameter(ctx.platform));
-  }
-}
-
-async function readFileContent(
-  filePath: string,
-  ctx: DriverContext,
-  envs: { [key in string]: string } | undefined,
-  fromPath: string
-): Promise<Result<string, FxError>> {
-  const ext = path.extname(filePath);
-  if (ext.toLowerCase() !== ".txt" && ext.toLowerCase() !== ".md") {
-    ctx.logProvider.error(
-      getLocalizedString("core.envFunc.unsupportedFile.errorLog", filePath, "txt")
-    );
-    return err(new UnsupportedFileFormatError(ctx.platform));
-  }
-
-  const absolutePath = getAbsolutePath(filePath, fromPath);
-  if (await fs.pathExists(absolutePath)) {
-    try {
-      let fileContent = await fs.readFile(absolutePath, "utf8");
-      fileContent = stripBom(fileContent);
-      let processedFileContent = expandEnvironmentVariable(fileContent, envs);
-      processedFileContent = processedFileContent.replace(/\r\n/g, "\n");
-      return ok(processedFileContent);
-    } catch (e) {
-      ctx.logProvider.error(
-        getLocalizedString("core.envFunc.readFile.errorLog", absolutePath, e?.toString())
-      );
-      return err(new ReadFileError(ctx.platform, absolutePath));
-    }
-  } else {
-    return err(new FileNotFoundError(source, filePath));
-  }
-}
-
-function getAbsolutePath(relativeOrAbsolutePath: string, fromPath: string): string {
-  return path.isAbsolute(relativeOrAbsolutePath)
-    ? relativeOrAbsolutePath
-    : path.join(path.dirname(fromPath), relativeOrAbsolutePath);
-}
-
 class UnsupportedFileFormatError extends UserError {
   constructor(platform: Platform | undefined) {
     const message =

packages/fx-core/tests/component/driver/teamsApp/manifestUtils.test.ts

@@ -10,6 +10,7 @@ import {
 } from "@microsoft/teamsfx-api";
 import fs from "fs-extra";
 import mockedEnv, { RestoreFn } from "mocked-env";
+import os from "os";
 import path from "path";
 import { assert, vi } from "vitest";
 import {
@@ -527,13 +528,18 @@ describe("trimManifestShortName", () => {
 describe("resolveLocFile", () => {
   const sandbox = vi;
   let mockedEnvRestore: RestoreFn;
+  let tmpDir: string | undefined;
 
-  afterEach(() => {
+  afterEach(async () => {
     if (mockedEnvRestore) {
       mockedEnvRestore();
     }
     vi.restoreAllMocks();
     vi.restoreAllMocks();
+    if (tmpDir) {
+      await fs.remove(tmpDir);
+      tmpDir = undefined;
+    }
   });
 
   it("returns error when loc file doesn't exist", async () => {
@@ -582,21 +588,17 @@ describe("resolveLocFile", () => {
   });
 
   it("resolves $[file(...)] when context is provided", async () => {
-    vi.spyOn(fs, "pathExists").mockImplementation(async (filePath) => {
-      return filePath === "loc_file_path" || filePath === "instruction.txt";
-    });
-    vi.spyOn(fs, "readFile").mockImplementation(((filePath: number | fs.PathLike) => {
-      if (filePath === "loc_file_path") {
-        return Promise.resolve(
-          JSON.stringify({
-            name: {
-              short: "$[file('instruction.txt')]",
-            },
-          })
-        );
-      }
-      return Promise.resolve("localized short name");
-    }) as any);
+    tmpDir = await fs.mkdtemp(path.join(os.tmpdir(), "resolveloc-"));
+    const locFilePath = path.join(tmpDir, "loc_file.json");
+    await fs.writeFile(
+      locFilePath,
+      JSON.stringify({
+        name: {
+          short: "$[file('instruction.txt')]",
+        },
+      })
+    );
+    await fs.writeFile(path.join(tmpDir, "instruction.txt"), "localized short name");
 
     const context: any = {
       platform: Platform.VSCode,
@@ -608,7 +610,7 @@ describe("resolveLocFile", () => {
       },
     };
 
-    const locFile = await manifestUtils.resolveLocFile("loc_file_path", context);
+    const locFile = await manifestUtils.resolveLocFile(locFilePath, context);
 
     assert.isTrue(locFile.isOk());
     if (locFile.isOk()) {