@factorialco/fcode-cli 2.2.0 → 2.4.0

package/dist/services/fcode-graphql-client.js

@@ -4,6 +4,10 @@ const graphql_request_1 = require("graphql-request");
 const types_1 = require("../core/types");
 const locale_merger_1 = require("./locale-merger");
 const _ = require("lodash");
+// Manifest fields an fcode-api older than this CLI may not know. The manifest query falls back to a
+// narrower selection when the error names one of them, so a CLI stays usable against an
+// on-premises api that has not been updated yet.
+const UNKNOWN_MANIFEST_FIELDS = ['isNative', 'inheritedDependencies'];
 // Shared team version selections so every query/mutation returns the same shape.
 const TEAM_VERSION_FIELDS = `
   id
@@ -67,6 +71,13 @@ const PROCESS_FIELDS = `
       appRole
       authMode
     }
+    uiTrigger {
+      enabled
+      locationId
+      label
+      icon
+      awaitResult
+    }
     dependencies {
       scopedToProcess
     }
@@ -90,6 +101,11 @@ class FcodeGraphQLClient {
             },
         });
     }
+    // Swap the bearer token on the live client (after a session refresh) so every
+    // holder of this instance — repositories, pushers, queries — uses the new one.
+    setAccessToken(accessToken) {
+        this.client.setHeader('authorization', `Bearer ${accessToken}`);
+    }
     isDuplicatedError(error) {
         return (error &&
             error.response &&
@@ -345,7 +361,10 @@ class FcodeGraphQLClient {
         catch (error) {
             return Promise.reject(this.cleanError(error));
         }
-        const merged = (0, locale_merger_1.mergeInheritedLocales)(locales);
+        // The cloud team's parent order is the inheritance precedence the merge must replicate; the
+        // local team.json may lag behind it, so the cloud is asked, not the file.
+        const { parentTeamSlugs } = await this.team();
+        const merged = (0, locale_merger_1.mergeInheritedLocales)(locales, parentTeamSlugs ?? []);
         (0, locale_merger_1.assertLocaleFilesCanCoexist)(merged);
         return merged;
     }
@@ -421,6 +440,21 @@ class FcodeGraphQLClient {
                 settings.formSettings.authMode = process.form.authMode;
             }
         }
+        if (process.uiTrigger) {
+            settings.uiTrigger = { enabled: process.uiTrigger.enabled };
+            if (process.uiTrigger.locationId) {
+                settings.uiTrigger.locationId = process.uiTrigger.locationId;
+            }
+            if (process.uiTrigger.label) {
+                settings.uiTrigger.label = process.uiTrigger.label;
+            }
+            if (process.uiTrigger.icon) {
+                settings.uiTrigger.icon = process.uiTrigger.icon;
+            }
+            if (process.uiTrigger.awaitResult !== undefined) {
+                settings.uiTrigger.awaitResult = process.uiTrigger.awaitResult;
+            }
+        }
         const input = {
             name: process.name,
             parametersSchema: process.script.parametersSchema,
@@ -637,6 +671,13 @@ class FcodeGraphQLClient {
                 isNative
                 gitUrl
               }
+              inheritedDependencies {
+                name
+                semVer
+                isNative
+                gitUrl
+                resolvingTeamSlug
+              }
             }
           }
         `, { programmingLanguage })
@@ -646,7 +687,10 @@ class FcodeGraphQLClient {
             .catch((error) => {
             // TODO: This is a workaround backward compatibility with old versions of fcode-api.
             // Remove when full on-premises installations are updated.
-            if (error.response && error.response.errors && error.response.errors[0] && error.response.errors[0].message.includes('isNative')) {
+            // `inheritedDependencies` is listed for the same reason `isNative` is: an api predating
+            // dependency inheritance rejects the whole query over the unknown field, and the fallback
+            // below simply reads no inherited dependencies.
+            if (error.response?.errors?.[0]?.message && UNKNOWN_MANIFEST_FIELDS.some((field) => error.response.errors[0].message.includes(field))) {
                 return this.client
                     .request((0, graphql_request_1.gql) `
                 query getProgrammingLanguageManifest($programmingLanguage: ProgrammingLanguage!) {
@@ -724,6 +768,21 @@ class FcodeGraphQLClient {
                 metadata.form.authMode = settings.formSettings.authMode;
             }
         }
+        if (settings?.uiTrigger) {
+            metadata.uiTrigger = { enabled: Boolean(settings.uiTrigger.enabled) };
+            if (settings.uiTrigger.locationId) {
+                metadata.uiTrigger.locationId = settings.uiTrigger.locationId;
+            }
+            if (settings.uiTrigger.label) {
+                metadata.uiTrigger.label = settings.uiTrigger.label;
+            }
+            if (settings.uiTrigger.icon) {
+                metadata.uiTrigger.icon = settings.uiTrigger.icon;
+            }
+            if (settings.uiTrigger.awaitResult) {
+                metadata.uiTrigger.awaitResult = true;
+            }
+        }
         return new types_1.Process(id, slug, script, readme, { dependencies }, settings, metadata, this.inheritedTeam(resolvingTeamSlug));
     }
     /**
@@ -860,6 +919,23 @@ class FcodeGraphQLClient {
             return Promise.reject(this.cleanError(error));
         });
     }
+    // Cheapest team-scoped query, used as a pre-flight access check so commands can
+    // fail once with a clear error before touching local state, instead of erroring
+    // on every resource pull.
+    verifyTeamAccess() {
+        return this.client
+            .request((0, graphql_request_1.gql) `
+          query team($slug: ID!) {
+            team(slug: $slug) {
+              slug
+            }
+          }
+        `, { slug: this.teamSlug })
+            .then(() => undefined)
+            .catch((error) => {
+            return Promise.reject(this.cleanError(error));
+        });
+    }
     team() {
         return this.client
             .request((0, graphql_request_1.gql) `
@@ -916,15 +992,23 @@ class FcodeGraphQLClient {
     }
     mapProgrammingLanguageManifest(programmingLanguageManifest) {
         const allDependencies = programmingLanguageManifest.nextInstallation?.dependencies || programmingLanguageManifest.dependencies;
-        const dependencies = _.map(allDependencies, (dependency) => {
-            if (!dependency.isNative) {
-                return { name: dependency.name, specifier: dependency.gitUrl ?? dependency.semVer };
+        return new types_1.ProgrammingLanguageManifest(programmingLanguageManifest.id, programmingLanguageManifest.programmingLanguage, programmingLanguageManifest.programmingLanguage, this.mapDependencies(allDependencies), 
+        // Absent when the api predates dependency inheritance, or when the workspace has no parents.
+        this.mapDependencies(programmingLanguageManifest.inheritedDependencies));
+    }
+    mapDependencies(dependencies) {
+        return _.map(dependencies, (dependency) => {
+            if (dependency.isNative) {
+                return null;
             }
-            return null;
+            return {
+                name: dependency.name,
+                specifier: dependency.gitUrl ?? dependency.semVer,
+                ...(dependency.resolvingTeamSlug && { resolvingTeamSlug: dependency.resolvingTeamSlug }),
+            };
         })
             .filter(Boolean)
-            .sort((a, b) => a && b && a.name.localeCompare(b.name));
-        return new types_1.ProgrammingLanguageManifest(programmingLanguageManifest.id, programmingLanguageManifest.programmingLanguage, programmingLanguageManifest.programmingLanguage, dependencies);
+            .sort((a, b) => a.name.localeCompare(b.name));
     }
     allProgrammingLanguageManifest() {
         const result = [];
@@ -958,7 +1042,11 @@ class FcodeGraphQLClient {
           }
         `, {
             id: programmingLanguageManifest.id,
-            input: { dependencies: programmingLanguageManifest.dependencies },
+            input: {
+                // Only name and specifier: DependencyUpdateInput has no other fields, and a workspace
+                // pushes its own list — inherited entries live in a separate file and never get here.
+                dependencies: programmingLanguageManifest.dependencies.map(({ name, specifier }) => ({ name, specifier })),
+            },
         })
             .then(({ updateProgrammingLanguageManifest: programmingLanguageManifest }) => {
             return this.client

package/dist/services/locale-merger.d.ts

@@ -11,7 +11,7 @@ import { Locale } from '../core/types';
  * several parents define is rewritten, as a flat mapping of dotted keys, which is the shape the
  * lookup uses anyway and the one shape where a nested and a dotted key cannot disagree.
  */
-export declare function mergeInheritedLocales(locales: Array<Locale>): Array<Locale>;
+export declare function mergeInheritedLocales(locales: Array<Locale>, parentTeamSlugs: Array<string>): Array<Locale>;
 /**
  * Locale identifiers are case-sensitive on the platform (pt-BR and pt-br are different locales),
  * but the filesystems macOS and Windows usually run on are not — both identifiers would collapse

package/dist/services/locale-merger.js

@@ -22,34 +22,37 @@ const locale_resolver_1 = require("./locale-resolver");
  * several parents define is rewritten, as a flat mapping of dotted keys, which is the shape the
  * lookup uses anyway and the one shape where a nested and a dotted key cannot disagree.
  */
-function mergeInheritedLocales(locales) {
+function mergeInheritedLocales(locales, parentTeamSlugs) {
     const inheritedByIdentifier = new Map();
     for (const locale of locales.filter((locale) => locale.resolvingTeamSlug)) {
         inheritedByIdentifier.set(locale.locale, [...(inheritedByIdentifier.get(locale.locale) ?? []), locale]);
     }
     return [
         ...locales.filter((locale) => !locale.resolvingTeamSlug),
-        ...[...inheritedByIdentifier.values()].map((files) => (files.length === 1 ? files[0] : mergeLocaleFiles(files))),
+        ...[...inheritedByIdentifier.values()].map((files) => files.length === 1 ? files[0] : mergeLocaleFiles(files, parentTeamSlugs)),
     ];
 }
 /**
- * The platform walks parents sorted by their slug — `Team.parentTeamIdsInResolutionOrder` — and
- * the first defining a key wins. Deriving that order here, rather than trusting the order the API
- * happened to list the rows in (which follows the listing's `orderBy`, `updatedAt` by default),
- * is what keeps a local run and the cloud resolving the same text.
+ * The platform walks parents in the team's configured order — `Team.parentTeamIdsInResolutionOrder`
+ * — and the first defining a key wins. Deriving that order here from the cloud team's
+ * `parentTeamSlugs`, rather than trusting the order the API happened to list the rows in (which
+ * follows the listing's `orderBy`, `updatedAt` by default), is what keeps a local run and the
+ * cloud resolving the same text.
  */
-function inResolutionOrder(files) {
-    return [...files].sort((a, b) => {
-        const [aSlug, bSlug] = [a.resolvingTeamSlug ?? '', b.resolvingTeamSlug ?? ''];
-        return aSlug < bSlug ? -1 : (aSlug > bSlug ? 1 : 0);
-    });
+function inResolutionOrder(files, parentTeamSlugs) {
+    const precedence = (file) => {
+        const index = parentTeamSlugs.indexOf(file.resolvingTeamSlug ?? '');
+        return index === -1 ? parentTeamSlugs.length : index;
+    };
+    return [...files].sort((a, b) => precedence(a) - precedence(b));
 }
 /**
  * @param files the same locale as every parent workspace defines it, in any order
+ * @param parentTeamSlugs the workspace's parents in inheritance-precedence order
  * @returns one locale carrying their merged translations, attributed to the winning parent
  */
-function mergeLocaleFiles(files) {
-    const ordered = inResolutionOrder(files);
+function mergeLocaleFiles(files, parentTeamSlugs) {
+    const ordered = inResolutionOrder(files, parentTeamSlugs);
     const [winner] = ordered;
     const translations = {};
     // Lowest precedence first, so the first parent in resolution order is the text that survives —

package/dist/services/locale-resolver.d.ts

@@ -10,9 +10,14 @@
 export declare function flattenTranslations(document: unknown, prefix?: string, target?: Record<string, string>): Record<string, string>;
 /**
  * @param requestedLocale the locale to run with, or undefined to use the workspace's primary
- * @returns the locale actually used and its flat translations, with the primary locale underneath
+ * @returns the locale actually used and its flat translations, with the primary locale underneath,
+ * plus each locale's own map (inherited file layered under its own, but NOT merged over the
+ * primary) so a call naming a locale (`fcode.i18n(key, args, { locale })`) resolves like the
+ * cloud's `by_locale`: key by key in the requested locale first, falling back to the merged
+ * translations
  */
 export declare function resolveLocalTranslations(requestedLocale?: string, workspaceDir?: string): {
     locale?: string;
     translations: Record<string, string>;
+    byLocale: Record<string, Record<string, string>>;
 };

package/dist/services/locale-resolver.js

@@ -107,14 +107,21 @@ function primaryLocaleOf(workspaceDir) {
 }
 /**
  * @param requestedLocale the locale to run with, or undefined to use the workspace's primary
- * @returns the locale actually used and its flat translations, with the primary locale underneath
+ * @returns the locale actually used and its flat translations, with the primary locale underneath,
+ * plus each locale's own map (inherited file layered under its own, but NOT merged over the
+ * primary) so a call naming a locale (`fcode.i18n(key, args, { locale })`) resolves like the
+ * cloud's `by_locale`: key by key in the requested locale first, falling back to the merged
+ * translations
  */
 function resolveLocalTranslations(requestedLocale, workspaceDir = process.cwd()) {
     const primary = primaryLocaleOf(workspaceDir);
     const locale = requestedLocale || primary;
+    const byLocale = Object.fromEntries(availableLocales(workspaceDir).map((slug) => [slug, readLocale(workspaceDir, slug)]));
     if (!locale) {
-        return { locale: undefined, translations: {} };
+        return { locale: undefined, translations: {}, byLocale };
     }
-    const fallback = primary && primary !== locale ? readLocale(workspaceDir, primary) : {};
-    return { locale, translations: { ...fallback, ...readLocale(workspaceDir, locale) } };
+    // `byLocale` already holds every locale's own file, so the merged map — the requested locale
+    // layered over the primary — is derived from it rather than read from disk a second time.
+    const fallback = primary ? byLocale[primary] : {};
+    return { locale, translations: { ...fallback, ...(byLocale[locale] ?? {}) }, byLocale };
 }

package/dist/services/team-access.d.ts

@@ -0,0 +1,13 @@
+import FcodeGraphQLClient from './fcode-graphql-client';
+import GlobalConfig from '../config/global';
+declare const TeamAccessService: {
+    globalConfig: GlobalConfig;
+    clientFactory: (options: {
+        url: string;
+        accessToken: string;
+        teamSlug: string;
+    }) => FcodeGraphQLClient;
+    ensureTeamAccess(url: string, slug: string): Promise<void>;
+    checkAccess(url: string, slug: string): Promise<void>;
+};
+export default TeamAccessService;

package/dist/services/team-access.js

@@ -0,0 +1,45 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const auth_service_1 = require("./auth-service");
+const fcode_graphql_client_1 = require("./fcode-graphql-client");
+const global_1 = require("../config/global");
+const errors_1 = require("../core/errors");
+function is403(error) {
+    return error?.response?.status === 403;
+}
+const TeamAccessService = {
+    globalConfig: new global_1.default(),
+    clientFactory: (options) => new fcode_graphql_client_1.default(options),
+    // Pre-flight check that the current session can access the team, run before any
+    // local state is touched so a denied session fails once with a clear error
+    // instead of erroring on every resource pull. A 403 may just mean the token
+    // predates the team: groups are snapshotted into the token at issuance
+    // (FCT-61231), so re-mint it through the refresh grant and retry once.
+    async ensureTeamAccess(url, slug) {
+        try {
+            await this.checkAccess(url, slug);
+        }
+        catch (error) {
+            if (!is403(error)) {
+                throw error;
+            }
+            if (!(await auth_service_1.default.refreshSession(url))) {
+                throw new errors_1.TeamAccessDenied(slug);
+            }
+            try {
+                await this.checkAccess(url, slug);
+            }
+            catch (retryError) {
+                if (is403(retryError)) {
+                    throw new errors_1.TeamAccessDenied(slug);
+                }
+                throw retryError;
+            }
+        }
+    },
+    async checkAccess(url, slug) {
+        const { token } = await this.globalConfig.getAuthInfo(url);
+        await this.clientFactory({ url, accessToken: token.access_token, teamSlug: slug }).verifyTeamAccess();
+    },
+};
+exports.default = TeamAccessService;

package/dist/services/team-versioning.d.ts

@@ -0,0 +1,16 @@
+import { Team, TeamAliasFileEntry, TeamVersion, TeamVersionAlias, TeamVersionFileEntry } from '../core/types';
+/**
+ * What a team:push must do to make the cloud's team versions and aliases match team.json.
+ * Versions are only ever created or deleted (tags are immutable snapshots); aliases are
+ * name->tag pointers, so a changed tag is an upsert of the same name.
+ */
+export interface TeamVersioningSyncPlan {
+    createVersions: TeamVersionFileEntry[];
+    deleteVersions: TeamVersion[];
+    setAliases: TeamAliasFileEntry[];
+    deleteAliases: TeamVersionAlias[];
+}
+export declare function planTeamVersioningSync(team: Team, cloudVersions: TeamVersion[], cloudAliases: TeamVersionAlias[]): TeamVersioningSyncPlan;
+export declare function teamVersioningSyncPlanIsEmpty(plan: TeamVersioningSyncPlan): boolean;
+/** Logs the per-entity outcome of publishing a team version and returns how many failed. */
+export declare function logTeamVersionManifest(teamVersion: TeamVersion): number;

package/dist/services/team-versioning.js

@@ -0,0 +1,40 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.planTeamVersioningSync = planTeamVersioningSync;
+exports.teamVersioningSyncPlanIsEmpty = teamVersioningSyncPlanIsEmpty;
+exports.logTeamVersionManifest = logTeamVersionManifest;
+const color_1 = require("@oclif/color");
+const cli_1 = require("../utils/cli");
+function planTeamVersioningSync(team, cloudVersions, cloudAliases) {
+    const localVersions = team.versions ?? [];
+    const localAliases = team.aliases ?? [];
+    const cloudVersionTags = new Set(cloudVersions.map(({ tag }) => tag));
+    const localVersionTags = new Set(localVersions.map(({ tag }) => tag));
+    const cloudAliasesByName = new Map(cloudAliases.map((alias) => [alias.name, alias]));
+    const localAliasNames = new Set(localAliases.map(({ name }) => name));
+    return {
+        createVersions: localVersions.filter(({ tag }) => !cloudVersionTags.has(tag)),
+        deleteVersions: cloudVersions.filter(({ tag }) => !localVersionTags.has(tag)),
+        setAliases: localAliases.filter(({ name, tag }) => cloudAliasesByName.get(name)?.tag !== tag),
+        deleteAliases: cloudAliases.filter(({ name }) => !localAliasNames.has(name)),
+    };
+}
+function teamVersioningSyncPlanIsEmpty(plan) {
+    return (plan.createVersions.length === 0 &&
+        plan.deleteVersions.length === 0 &&
+        plan.setAliases.length === 0 &&
+        plan.deleteAliases.length === 0);
+}
+/** Logs the per-entity outcome of publishing a team version and returns how many failed. */
+function logTeamVersionManifest(teamVersion) {
+    const created = teamVersion.manifest.filter(({ outcome }) => outcome === 'CREATED');
+    const skipped = teamVersion.manifest.filter(({ outcome }) => outcome === 'SKIPPED_EXISTS');
+    const failed = teamVersion.manifest.filter(({ outcome }) => outcome === 'FAILED');
+    cli_1.default.log(color_1.default.green(`✅ ${created.length} created`) +
+        `, ${skipped.length} skipped (tag already exists)` +
+        (failed.length > 0 ? `, ${color_1.default.red(`${failed.length} failed`)}` : ''));
+    for (const entry of failed) {
+        cli_1.default.error(`${entry.resourceType.toLowerCase()} ${entry.slug} — ${entry.error ?? 'unknown error'}`);
+    }
+    return failed.length;
+}

package/dist/utils/gitignore.d.ts

@@ -1,5 +1,6 @@
 export declare const INHERITED_BLOCK_START = "# BEGIN fcode inherited resources (auto-generated, do not edit)";
 export declare const INHERITED_BLOCK_END = "# END fcode inherited resources";
+export declare const INHERITED_DEPENDENCY_FILES: string[];
 /**
  * Rebuilds the managed "inherited resources" block in a .gitignore.
  *
@@ -14,6 +15,7 @@ export declare function renderGitignoreWithInherited(existing: string, inherited
  * parent team and pulled read-only) are not tracked by git. Regenerated from the
  * current workspace metadata, so resources that stop being inherited drop out.
  * Inherited variable values live in one file, which is ignored as soon as the
- * workspace inherits any variable; inherited locales are one file each, like modules.
+ * workspace inherits any variable; inherited locales are one file each, like modules;
+ * inherited dependencies are one file per language, like variables.
  */
 export declare function syncInheritedGitignore(workspaceDir?: string): Promise<void>;

package/dist/utils/gitignore.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.INHERITED_BLOCK_END = exports.INHERITED_BLOCK_START = void 0;
+exports.INHERITED_DEPENDENCY_FILES = exports.INHERITED_BLOCK_END = exports.INHERITED_BLOCK_START = void 0;
 exports.renderGitignoreWithInherited = renderGitignoreWithInherited;
 exports.syncInheritedGitignore = syncInheritedGitignore;
 const path = require("node:path");
@@ -8,10 +8,14 @@ const fs = require("fs-extra");
 const workspace_1 = require("../config/workspace");
 const global_1 = require("../config/global");
 const settings_1 = require("../config/settings");
+const programming_language_manifest_1 = require("../repositories/programming-language-manifest");
 const filenamify_1 = require("./filenamify");
 const file_utils_1 = require("./file-utils");
 exports.INHERITED_BLOCK_START = '# BEGIN fcode inherited resources (auto-generated, do not edit)';
 exports.INHERITED_BLOCK_END = '# END fcode inherited resources';
+// Derived from the repository that writes them, so renaming a file cannot silently stop it being
+// gitignored.
+exports.INHERITED_DEPENDENCY_FILES = Object.values(programming_language_manifest_1.INHERITED_FILE_NAME).map((name) => `${programming_language_manifest_1.DEPENDENCIES_DIR}/${name}`);
 /**
  * Rebuilds the managed "inherited resources" block in a .gitignore.
  *
@@ -46,7 +50,8 @@ function stripManagedBlock(content) {
  * parent team and pulled read-only) are not tracked by git. Regenerated from the
  * current workspace metadata, so resources that stop being inherited drop out.
  * Inherited variable values live in one file, which is ignored as soon as the
- * workspace inherits any variable; inherited locales are one file each, like modules.
+ * workspace inherits any variable; inherited locales are one file each, like modules;
+ * inherited dependencies are one file per language, like variables.
  */
 async function syncInheritedGitignore(workspaceDir = process.cwd()) {
     const team = await new workspace_1.default(workspaceDir).getActiveTeam();
@@ -62,6 +67,10 @@ async function syncInheritedGitignore(workspaceDir = process.cwd()) {
         ...Object.values(team.i18n ?? {})
             .filter((locale) => locale.resolvingTeamSlug)
             .map((locale) => `i18n/${(0, filenamify_1.default)(locale.slug)}.yaml`),
+        // Inherited dependencies are one file per language, written only when there is something to
+        // inherit — checked on disk because the manifest metadata tracks the workspace's own list, not
+        // what its parents contribute.
+        ...exports.INHERITED_DEPENDENCY_FILES.filter((file) => fs.existsSync(path.join(workspaceDir, file))),
     ];
     const gitignorePath = path.join(workspaceDir, '.gitignore');
     const existing = fs.existsSync(gitignorePath) ? fs.readFileSync(gitignorePath, 'utf8') : '';

package/oclif.manifest.json

@@ -1675,11 +1675,19 @@
     "team:pull": {
       "aliases": [],
       "args": {},
-      "description": "Fetch team settings (timezone, error handler, inheritance) from cloud into team.json",
+      "description": "Fetch team settings (timezone, error handler, inheritance) and team versions/aliases from cloud into team.json",
       "examples": [
         "$ fcode team:pull"
       ],
-      "flags": {},
+      "flags": {
+        "force": {
+          "char": "f",
+          "description": "Force command",
+          "name": "force",
+          "allowNo": false,
+          "type": "boolean"
+        }
+      },
       "hasDynamicHelp": false,
       "hiddenAliases": [],
       "id": "team:pull",
@@ -1698,7 +1706,7 @@
     "team:push": {
       "aliases": [],
       "args": {},
-      "description": "Update cloud team settings (timezone, error handler, inheritance, webhook auth) from team.json",
+      "description": "Update cloud team settings (timezone, error handler, inheritance, webhook auth) and sync team versions/aliases from team.json",
       "examples": [
         "$ fcode team:push"
       ],
@@ -1729,7 +1737,7 @@
     "team:status": {
       "aliases": [],
       "args": {},
-      "description": "Show whether team settings (timezone, error handler, inheritance) differ from the cloud",
+      "description": "Show whether team settings (timezone, error handler, inheritance) or team versions/aliases differ from the cloud",
       "examples": [
         "$ fcode team:status"
       ],
@@ -2163,5 +2171,5 @@
       ]
     }
   },
-  "version": "2.2.0"
+  "version": "2.4.0"
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@factorialco/fcode-cli",
-  "version": "2.2.0",
+  "version": "2.4.0",
   "packageManager": "pnpm@11.7.0",
   "description": "Factorial Code Command Line Interface",
   "homepage": "https://code.factorialhr.com/docs/cli/",