support PBB app feature types in manifest and prompts (#165)

* support PBB app feature types in manifest and prompts

Fetch active types from /apps_ms/public/platform-building-blocks-schemas
at runtime and merge with the static AppFeatureType enum so manifests can
declare PBB-only types (incl. action-family blocks) without enum maintenance.
Falls back to enum-only when the endpoint is unreachable.

Co-authored-by: Cursor <cursoragent@cursor.com>

* bump version

---------

Co-authored-by: Cursor <cursoragent@cursor.com>

Author: oricho123

package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mondaycom/apps-cli",
-  "version": "4.10.5",
+  "version": "4.10.6",
   "description": "A cli tool to manage apps (and monday-code projects) in monday.com",
   "author": "monday.com Apps Team",
   "type": "module",

src/commands/app-features/create.ts

@@ -2,8 +2,10 @@ import { Flags } from '@oclif/core';
 
 import { AuthenticatedCommand } from 'commands-base/authenticated-command';
 import { APP_ID_TO_ENTER, APP_VERSION_ID_TO_ENTER } from 'consts/messages';
+import { getValidAppFeatureTypes } from 'services/app-feature-types-service';
 import { createAppFeature } from 'services/app-features-service';
 import { DynamicChoicesService } from 'services/dynamic-choices-service';
+import { pbbSchemaManager } from 'services/pbb-schema-manager';
 import { PromptService } from 'services/prompt-service';
 import { AppFeatureType } from 'types/services/app-features-service';
 import logger from 'utils/logger';
@@ -67,8 +69,9 @@ export default class Create extends AuthenticatedCommand {
         appFeatureName = await PromptService.promptInput('Please enter feature name');
       }
 
+      await pbbSchemaManager.initialize();
       if (
-        !(Object.values(AppFeatureType) as string[]).includes(appFeatureType) ||
+        !getValidAppFeatureTypes().includes(appFeatureType) ||
         appFeatureType === (AppFeatureType.AppFeatureOauth as string)
       ) {
         logger.error(`Invalid feature type`);

src/commands/app/deploy.ts

@@ -64,7 +64,7 @@ export default class AppDeploy extends AuthenticatedCommand {
       let { appId, appVersionId } = flags;
       const region = getRegionFromString(flags?.region);
       const manifestFileDir = directoryPath || getCurrentWorkingDirectory();
-      const manifestFileData = readManifestFile(manifestFileDir);
+      const manifestFileData = await readManifestFile(manifestFileDir);
       appId = appId || manifestFileData.app.id;
 
       appVersionId = await this.getAppVersionId(appVersionId, appId, force);

src/consts/urls.ts

@@ -146,3 +146,7 @@ export const makeAppManifestExportableUrl = (appId: AppId): string => {
 export const getDeploymentSecurityScanUrl = (appVersionId: number): string => {
   return `${appVersionIdBaseUrl(appVersionId)}/deployments/security-scan`;
 };
+
+export const platformBuildingBlocksSchemasUrl = (): string => {
+  return `/apps_ms/public/platform-building-blocks-schemas`;
+};

src/services/__tests__/manifest-service.test.ts

@@ -5,16 +5,16 @@ import { readManifestFile } from 'services/manifest-service';
 
 describe('ManifestService', () => {
   describe('readManifestFile', () => {
-    it('should read manifest file', () => {
-      const manifest = readManifestFile('src/services/__tests__/mocks/', 'manifest-mock.yml');
+    it('should read manifest file', async () => {
+      const manifest = await readManifestFile('src/services/__tests__/mocks/', 'manifest-mock.yml');
       expect(manifest?.app?.id).toEqual(undefined);
       expect(manifest?.app?.hosting?.cdn?.path).toEqual('./build');
       expect(manifest?.app?.hosting?.server?.path).toEqual('./server');
       expect(manifest?.version).toEqual('1.0.0');
     });
 
-    it('should raise an error if manifest file is not valid', () => {
-      expect(() => readManifestFile('src/services/__tests__/mocks/', 'invalid-manifest-mock.yml')).toThrowError();
+    it('should raise an error if manifest file is not valid', async () => {
+      await expect(readManifestFile('src/services/__tests__/mocks/', 'invalid-manifest-mock.yml')).rejects.toThrow();
     });
   });
 });

src/services/app-feature-types-service.ts

@@ -0,0 +1,8 @@
+import { pbbSchemaManager } from 'services/pbb-schema-manager';
+import { AppFeatureType } from 'types/services/app-features-service';
+
+export const getValidAppFeatureTypes = (): string[] => {
+  const enumTypes = Object.values(AppFeatureType) as string[];
+  const pbbTypes = pbbSchemaManager.getActiveTypeNames();
+  return [...new Set([...enumTypes, ...pbbTypes])];
+};

src/services/apps-service.ts

@@ -73,7 +73,7 @@ export const cloneAppTemplateAndLoadManifest = async (
   };
 
   await cloneFolderFromGitRepo(ctx.githubUrl, ctx.folder, ctx.branch, ctx.targetPath, output);
-  const manifestData = readManifestFile(ctx.targetPath);
+  const manifestData = await readManifestFile(ctx.targetPath);
   ctx.appName = ctx.appName || manifestData.app.name;
   ctx.features = manifestData.app.features;
 };

src/services/dynamic-choices-service.ts

@@ -1,9 +1,11 @@
 import { APP_TEMPLATES_CONFIG } from 'consts/app-templates-config';
 import { APP_VERSION_STATUS } from 'consts/app-versions';
 import { listAppBuilds } from 'services/app-builds-service';
+import { getValidAppFeatureTypes } from 'services/app-feature-types-service';
 import { listAppFeaturesByAppVersionId } from 'services/app-features-service';
 import { defaultVersionByAppId, listAppVersionsByAppId } from 'services/app-versions-service';
 import { listApps } from 'services/apps-service';
+import { pbbSchemaManager } from 'services/pbb-schema-manager';
 import { PromptService } from 'services/prompt-service';
 import { LIVE_VERSION_ERROR_LOG } from 'src/consts/messages';
 import { AppId } from 'src/types/general';
@@ -77,11 +79,13 @@ export const DynamicChoicesService = {
     return { appId: chosenAppId, appVersionId };
   },
 
-  async chooseAppFeatureType(excludeTypes?: AppFeatureType[]) {
-    const featureTypes = Object.values(AppFeatureType);
-    const featureTypeChoicesMap: Record<string, AppFeatureType> = {};
+  async chooseAppFeatureType(excludeTypes?: Array<AppFeatureType | string>) {
+    await pbbSchemaManager.initialize();
+    const featureTypes = getValidAppFeatureTypes();
+    const excluded = new Set<string>(excludeTypes);
+    const featureTypeChoicesMap: Record<string, string> = {};
     for (const featureType of featureTypes) {
-      if (excludeTypes?.includes(featureType)) continue;
+      if (excluded.has(featureType)) continue;
       featureTypeChoicesMap[featureType] = featureType;
     }
 

src/services/manifest-service.ts

@@ -4,6 +4,7 @@ import { join } from 'node:path';
 import { load } from 'js-yaml';
 
 import { BadConfigError } from 'errors/bad-config-error';
+import { pbbSchemaManager } from 'services/pbb-schema-manager';
 import { ManifestFileSchema } from 'services/schemas/manifest-service-schemas';
 import { BUILD_TYPES, BUILD_TYPES_MANIFEST_FORMAT } from 'types/services/app-features-service';
 import logger from 'utils/logger';
@@ -16,14 +17,15 @@ const checkConfigExists = (directoryPath: string, fileName = MANIFEST_FILE_NAME)
   return existsSync(filePath);
 };
 
-export const readManifestFile = (directoryPath: string, fileName = MANIFEST_FILE_NAME) => {
+export const readManifestFile = async (directoryPath: string, fileName = MANIFEST_FILE_NAME) => {
   if (!checkConfigExists(directoryPath, fileName)) {
     throw new BadConfigError(`the file: ${fileName} is not found in ${directoryPath}`);
   }
 
   const filePath = join(directoryPath, fileName);
   const stringifiedData = readFileSync(filePath, { encoding: ENCODING });
   const data = load(stringifiedData);
+  await pbbSchemaManager.initialize();
   try {
     return ManifestFileSchema.parse(data);
   } catch (error) {

src/services/pbb-schema-manager.ts

@@ -0,0 +1,77 @@
+import crypto from 'node:crypto';
+import https from 'node:https';
+
+import axios from 'axios';
+
+import { platformBuildingBlocksSchemasUrl } from 'consts/urls';
+import logger from 'utils/logger';
+import { appsUrlBuilder } from 'utils/urls-builder';
+
+type PbbSchemaEntry = {
+  name?: string;
+  status?: string;
+};
+
+const TWO_HOURS_IN_MS = 1000 * 60 * 60 * 2;
+const FETCH_TIMEOUT_IN_MS = 5000;
+
+class PbbSchemaManager {
+  private activeTypeNames: string[] = [];
+  private lastFetchedAt?: number;
+  private fetchPromise?: Promise<void>;
+
+  public async initialize(): Promise<void> {
+    if (this.fetchPromise) {
+      return this.fetchPromise;
+    }
+
+    if (this.isInitialized()) {
+      return;
+    }
+
+    this.fetchPromise = this.fetchSchemas();
+    try {
+      await this.fetchPromise;
+    } finally {
+      this.fetchPromise = undefined;
+    }
+  }
+
+  public getActiveTypeNames(): string[] {
+    return [...this.activeTypeNames];
+  }
+
+  public isInitialized(): boolean {
+    return (
+      this.activeTypeNames.length > 0 &&
+      this.lastFetchedAt !== undefined &&
+      this.lastFetchedAt + TWO_HOURS_IN_MS > Date.now()
+    );
+  }
+
+  private async fetchSchemas(): Promise<void> {
+    try {
+      const url = appsUrlBuilder(platformBuildingBlocksSchemasUrl());
+      const httpsAgent = new https.Agent({
+        secureOptions: crypto.constants.SSL_OP_LEGACY_SERVER_CONNECT,
+        rejectUnauthorized: false,
+      });
+
+      const response = await axios.get<PbbSchemaEntry[]>(url, {
+        timeout: FETCH_TIMEOUT_IN_MS,
+        headers: { Accept: 'application/json' },
+        httpsAgent,
+      });
+
+      const schemas = Array.isArray(response.data) ? response.data : [];
+      this.activeTypeNames = schemas
+        .filter(schema => schema.status === 'ACTIVE' && typeof schema.name === 'string' && schema.name.length > 0)
+        .map(schema => schema.name as string);
+      this.lastFetchedAt = Date.now();
+    } catch (error) {
+      logger.debug(error, 'pbb-schema-manager');
+    }
+  }
+}
+
+export const pbbSchemaManager = new PbbSchemaManager();