feat(tsp): run npm/install and typeSpec/compile before package for TSP projects (#14194)

* perf(tsp): run npm/install and typeSpec/compile before package for TSP projects

* perf: fix comment

Author: KennethBWSong

packages/fx-core/src/common/projectTypeChecker.ts

@@ -13,6 +13,7 @@ import {
   MetadataV3,
   MetadataV4,
 } from "./versionMetadata";
+import { pathUtils } from "../component/utils/pathUtils";
 
 export const TeamsJsModule = "@microsoft/teams-js";
 
@@ -304,4 +305,15 @@ export function IsDeclarativeAgentManifest(manifest: any): boolean {
     manifest.copilotAgents?.declarativeAgents && manifest.copilotAgents.declarativeAgents.length > 0
   );
 }
+
+export function isTypeSpecProject(projectPath: string): boolean {
+  const yamlFilePath = pathUtils.getYmlFilePath(projectPath);
+  if (!yamlFilePath) {
+    return false;
+  }
+
+  const yamlContent = fs.readFileSync(yamlFilePath, "utf8");
+  return yamlContent.includes("typeSpec/compile");
+}
+
 export const projectTypeChecker = new ProjectTypeChecker();

packages/fx-core/src/common/tools.ts

@@ -13,6 +13,9 @@ import { GraphReadUserScopes, SPFxScopes } from "./constants";
 import fs from "fs-extra";
 import path from "path";
 import { MetadataV3, MetadataV4 } from "./versionMetadata";
+import { pathUtils } from "../component/utils/pathUtils";
+import { TypeSpecCompileArgs } from "../component/driver/typeSpec/interface/typeSpecCompileArgs";
+import { parseDocument } from "yaml";
 
 export async function getSideloadingStatus(token: string): Promise<boolean | undefined> {
   return teamsDevPortalClient.getSideloadingStatus(token);
@@ -114,3 +117,38 @@ export function isTestToolEnabledProject(projectPath: string): boolean {
   }
   return false;
 }
+
+export function getTypeSpecArgs(projectPath: string): TypeSpecCompileArgs {
+  const defaultArgs = {
+    path: "./main.tsp",
+    manifestPath: "./appPackage/manifest.json",
+    outputDir: "./appPackage/.generated",
+    typeSpecConfigPath: "./tspconfig.yaml",
+  };
+  const yamlFilePath = pathUtils.getYmlFilePath(projectPath);
+  if (!yamlFilePath) {
+    return defaultArgs;
+  }
+
+  const yamlContent = fs.readFileSync(yamlFilePath, "utf8");
+  const document = parseDocument(yamlContent);
+  const provisionNode = document.get("provision") as any;
+  if (!provisionNode) {
+    return defaultArgs;
+  }
+
+  const tspCompileAction = provisionNode.items.find(
+    (item: any) => item.get("uses") === "typeSpec/compile"
+  );
+  if (!tspCompileAction) {
+    return defaultArgs;
+  }
+
+  const args = tspCompileAction.get("with");
+  return {
+    path: args.get("path") ?? defaultArgs.path,
+    manifestPath: args.get("manifestPath") ?? defaultArgs.manifestPath,
+    outputDir: args.get("outputDir") ?? defaultArgs.outputDir,
+    typeSpecConfigPath: args.get("typeSpecConfigPath") ?? defaultArgs.typeSpecConfigPath,
+  };
+}

packages/fx-core/src/core/FxCore.ts

@@ -69,6 +69,7 @@ import {
 import {
   IsDeclarativeAgentManifest,
   ProjectTypeResult,
+  isTypeSpecProject,
   projectTypeChecker,
 } from "../common/projectTypeChecker";
 import { TelemetryEvent, TelemetryProperty, telemetryUtils } from "../common/telemetry";
@@ -205,6 +206,10 @@ import { CoreTelemetryEvent, CoreTelemetryProperty } from "./telemetry";
 import { CoreHookContext, PreProvisionResForVS, VersionCheckRes } from "./types";
 import { InstallAppArgs } from "../component/driver/devChannel/interfaces/InstallAppArgs";
 import { TemplateNames } from "../component/generator/templates/templateNames";
+import { getTypeSpecArgs } from "../common/tools";
+import { NpmBuildDriver } from "../component/driver/script/npmBuildDriver";
+import { TypeSpecCompileDriver } from "../component/driver/typeSpec/compile";
+import { TypeSpecCompileArgs } from "../component/driver/typeSpec/interface/typeSpecCompileArgs";
 
 export class FxCore {
   constructor(tools: Tools) {
@@ -1259,6 +1264,30 @@ export class FxCore {
 
     const context: DriverContext = createDriverContext(inputs);
 
+    // For TSP projects
+    const isTspProject = isTypeSpecProject(inputs.projectPath!);
+    if (isTspProject) {
+      // Call npm/install
+      const npmInstallDriver: NpmBuildDriver = Container.get("cli/runNpmCommand");
+      const npmInstallArgs = {
+        args: "install --no-audit --progress=false",
+      };
+      const npmInstallResult = (await npmInstallDriver.execute(npmInstallArgs, context)).result;
+      if (npmInstallResult.isErr()) {
+        throw err(npmInstallResult.error);
+      }
+
+      // call typespec/compile
+      const typeSpecCompileDriver: TypeSpecCompileDriver = Container.get("typeSpec/compile");
+      const typeSpecCompileArgs: TypeSpecCompileArgs = getTypeSpecArgs(inputs.projectPath!);
+      const typeSpecCompileResult = (
+        await typeSpecCompileDriver.execute(typeSpecCompileArgs, context)
+      ).result;
+      if (typeSpecCompileResult.isErr()) {
+        throw err(typeSpecCompileResult.error);
+      }
+    }
+
     const teamsAppManifestFilePath = inputs?.[QuestionNames.TeamsAppManifestFilePath] as string;
 
     const driver: CreateAppPackageDriver = Container.get("teamsApp/zipAppPackage");

packages/fx-core/tests/common/projectTypeChecker.test.ts

@@ -11,10 +11,13 @@ import {
   SPFxKey,
   TeamsfxVersionState,
   getCapabilities,
+  isTypeSpecProject,
   projectTypeChecker,
 } from "../../src/common/projectTypeChecker";
 import { MetadataV2, MetadataV3 } from "../../src/common/versionMetadata";
 import { IsDeclarativeAgentManifest } from "../../build/common/projectTypeChecker";
+import { pathUtils } from "../../src/component/utils/pathUtils";
+import * as chai from "chai";
 
 describe("ProjectTypeChecker", () => {
   const sandbox = sinon.createSandbox();
@@ -547,4 +550,31 @@ describe("ProjectTypeChecker", () => {
       assert.isFalse(isDeclarativeAgent);
     });
   });
+
+  describe("isTypeSpecProject", () => {
+    const sandbox = sinon.createSandbox();
+    afterEach(() => {
+      sandbox.restore();
+    });
+
+    it("should return true if TypeSpec project", () => {
+      sandbox.stub(pathUtils, "getYmlFilePath").returns("m365agents.yml");
+      sandbox.stub(fs, "readFileSync").returns("provision: typeSpec/compile with: []");
+      const result = isTypeSpecProject("test-project-path");
+      chai.expect(result).to.be.true;
+    });
+
+    it("should return false if no yaml file", () => {
+      sandbox.stub(pathUtils, "getYmlFilePath").returns(undefined);
+      const result = isTypeSpecProject("test-project-path");
+      chai.expect(result).to.be.false;
+    });
+
+    it("should return false if not TypeSpec project", () => {
+      sandbox.stub(pathUtils, "getYmlFilePath").returns("m365agents.yml");
+      sandbox.stub(fs, "readFileSync").returns("provision: aadApp/create with: []");
+      const result = isTypeSpecProject("test-project-path");
+      chai.expect(result).to.be.false;
+    });
+  });
 });

packages/fx-core/tests/common/tools.test.ts

@@ -19,13 +19,15 @@ import {
   listDevTunnels,
   isTestToolEnabledProject,
   isSandboxedEnabled,
+  getTypeSpecArgs,
 } from "../../src/common/tools";
 import { PackageService } from "../../src/component/m365/packageService";
 import { isVideoFilterProject } from "../../src/core/middleware/videoFilterAppBlocker";
 import { isUserCancelError } from "../../src/error/common";
 import { MockedM365Provider, MockTools } from "../core/utils";
 import { GraphClient } from "../../src/client/graphClient";
 import { setTools } from "../../src/common/globalVars";
+import { pathUtils } from "../../src";
 
 chai.use(chaiAsPromised);
 
@@ -446,4 +448,78 @@ projectId: 00000000-0000-0000-0000-000000000000`;
       chai.expect(result).to.be.false;
     });
   });
+
+  describe("getTypeSpecArgs", () => {
+    const sandbox = sinon.createSandbox();
+    afterEach(() => {
+      sandbox.restore();
+    });
+
+    it("should return default args if no yaml file", () => {
+      sandbox.stub(pathUtils, "getYmlFilePath").returns(undefined);
+      const result = getTypeSpecArgs("test-project-path");
+      chai.expect(result).to.deep.equal({
+        path: "./main.tsp",
+        manifestPath: "./appPackage/manifest.json",
+        outputDir: "./appPackage/.generated",
+        typeSpecConfigPath: "./tspconfig.yaml",
+      });
+    });
+
+    it("should return default args if no provision node", () => {
+      sandbox.stub(pathUtils, "getYmlFilePath").returns("m365agents.yml");
+      sandbox.stub(fs, "readFileSync").returns("version: 1.0.0");
+      const result = getTypeSpecArgs("test-project-path");
+      chai.expect(result).to.deep.equal({
+        path: "./main.tsp",
+        manifestPath: "./appPackage/manifest.json",
+        outputDir: "./appPackage/.generated",
+        typeSpecConfigPath: "./tspconfig.yaml",
+      });
+    });
+
+    it("should return default args if no tspCompileAction", () => {
+      sandbox.stub(pathUtils, "getYmlFilePath").returns("m365agents.yml");
+      sandbox.stub(fs, "readFileSync").returns("provision: []");
+      const result = getTypeSpecArgs("test-project-path");
+      chai.expect(result).to.deep.equal({
+        path: "./main.tsp",
+        manifestPath: "./appPackage/manifest.json",
+        outputDir: "./appPackage/.generated",
+        typeSpecConfigPath: "./tspconfig.yaml",
+      });
+    });
+
+    it("should return args from tspCompileAction", () => {
+      sandbox.stub(pathUtils, "getYmlFilePath").returns("m365agents.yml");
+      sandbox
+        .stub(fs, "readFileSync")
+        .returns(
+          "provision:\n  - uses: typeSpec/compile\n    with:\n      path: ./custom.tsp\n      manifestPath: ./customManifest.json\n      outputDir: ./customOutputDir\n      typeSpecConfigPath: ./customTspconfig.yaml"
+        );
+      const result = getTypeSpecArgs("test-project-path");
+      chai.expect(result).to.deep.equal({
+        path: "./custom.tsp",
+        manifestPath: "./customManifest.json",
+        outputDir: "./customOutputDir",
+        typeSpecConfigPath: "./customTspconfig.yaml",
+      });
+    });
+
+    it("should return args from default if missing parameter", () => {
+      sandbox.stub(pathUtils, "getYmlFilePath").returns("m365agents.yml");
+      sandbox
+        .stub(fs, "readFileSync")
+        .returns(
+          "provision:\n  - uses: typeSpec/compile\n    with:\n      path2: ./custom.tsp\n      manifestPath2: ./customManifest.json\n      outputDir2: ./customOutputDir\n      typeSpecConfigPath2: ./customTspconfig.yaml"
+        );
+      const result = getTypeSpecArgs("test-project-path");
+      chai.expect(result).to.deep.equal({
+        path: "./main.tsp",
+        manifestPath: "./appPackage/manifest.json",
+        outputDir: "./appPackage/.generated",
+        typeSpecConfigPath: "./tspconfig.yaml",
+      });
+    });
+  });
 });

packages/fx-core/tests/core/FxCore.test.ts

@@ -126,6 +126,10 @@ import { validationUtils } from "../../src/ui/validationUtils";
 import { MockTools, MockUserInteraction, randomAppName } from "./utils";
 import { TabCapabilityOptions } from "../../src/question/scaffold/vsc/CapabilityOptions";
 import { InstallAppToChannelDriver } from "../../src/component/driver/devChannel/installApp";
+import * as CommonTools from "../../src/common/tools";
+import * as ProjecTypeChecker from "../../src/common/projectTypeChecker";
+import { NpmBuildDriver } from "../../src/component/driver/script/npmBuildDriver";
+import { TypeSpecCompileDriver } from "../../src/component/driver/typeSpec/compile";
 
 const tools = new MockTools();
 
@@ -2283,6 +2287,43 @@ describe("Teams app APIs", async () => {
     sinon.assert.calledOnce(showMessageStub);
   });
 
+  it("create app package with TypeSpec project", async () => {
+    setTools(tools);
+    const appName = await mockV3Project();
+    const inputs: Inputs = {
+      platform: Platform.VSCode,
+      [QuestionNames.Folder]: os.tmpdir(),
+      [QuestionNames.TeamsAppManifestFilePath]: ".\\appPackage\\manifest.json",
+      projectPath: path.join(os.tmpdir(), appName),
+      [QuestionNames.OutputZipPathParamName]: ".\\build\\appPackage\\appPackage.dev.zip",
+    };
+    const isTypeSpecProjectStub = sinon.stub(ProjecTypeChecker, "isTypeSpecProject").returns(true);
+    const getTypeSpecArgsStub = sinon.stub(CommonTools, "getTypeSpecArgs").returns({
+      path: "./main.tsp",
+      manifestPath: "./appPackage/manifest.json",
+      outputDir: "./appPackage/.generated",
+      typeSpecConfigPath: "./tspconfig.yaml",
+    });
+    const npmInstallStub = sinon
+      .stub(NpmBuildDriver.prototype, "execute")
+      .resolves({ result: ok(new Map()), summaries: [] });
+    const typeSpecCompileStub = sinon
+      .stub(TypeSpecCompileDriver.prototype, "execute")
+      .resolves({ result: ok(new Map()), summaries: [] });
+    sinon.stub(process, "platform").value("win32");
+    const runStub = sinon
+      .stub(CreateAppPackageDriver.prototype, "execute")
+      .resolves({ result: ok(new Map()), summaries: [] });
+    const showMessageStub = sinon.stub(tools.ui, "showMessage");
+    await core.createAppPackage(inputs);
+    sinon.assert.calledOnce(runStub);
+    sinon.assert.calledOnce(showMessageStub);
+    sinon.assert.calledOnce(isTypeSpecProjectStub);
+    sinon.assert.calledOnce(getTypeSpecArgsStub);
+    sinon.assert.calledOnce(npmInstallStub);
+    sinon.assert.calledOnce(typeSpecCompileStub);
+  });
+
   it("publish application", async () => {
     const appName = await mockV3Project();
     const inputs: Inputs = {