@factorialco/fcode-cli 2.3.0 → 2.4.0

package/dist/repositories/programming-language-manifest.js

@@ -1,5 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.DEPENDENCIES_DIR = exports.INHERITED_FILE_NAME = void 0;
 const fs = require("fs-extra");
 const path = require("node:path");
 const errors_1 = require("../core/errors");
@@ -7,6 +8,15 @@ const types_1 = require("../core/types");
 const resource_1 = require("./resource");
 const dependencies_1 = require("../core/utils/dependencies");
 const file_utils_1 = require("../utils/file-utils");
+/**
+ * The inherited file each language collapses its parents into. Exported so the gitignore sync names
+ * exactly what this repository writes, rather than repeating the strings.
+ */
+exports.INHERITED_FILE_NAME = {
+    JAVASCRIPT: 'package.inherited.json',
+    PYTHON: 'requirements.inherited.txt',
+};
+exports.DEPENDENCIES_DIR = 'dependencies';
 class ProgrammingLanguageManifestRepository extends resource_1.default {
     constructor() {
         super({
@@ -21,7 +31,7 @@ class ProgrammingLanguageManifestRepository extends resource_1.default {
         }
         const sourceCodeFileContent = fs.readFileSync(this.getResourcePath(programmingLanguageManifest));
         try {
-            return new types_1.ProgrammingLanguageManifest(programmingLanguageManifest.id, programmingLanguageManifest.slug, programmingLanguageManifest.programmingLanguage, (0, dependencies_1.dependenciesFromFile)(programmingLanguageManifest.programmingLanguage, sourceCodeFileContent.toString()));
+            return new types_1.ProgrammingLanguageManifest(programmingLanguageManifest.id, programmingLanguageManifest.slug, programmingLanguageManifest.programmingLanguage, (0, dependencies_1.dependenciesFromFile)(programmingLanguageManifest.programmingLanguage, sourceCodeFileContent.toString()), this.readInheritedDependencies(programmingLanguageManifest.programmingLanguage));
         }
         catch (error) {
             throw new errors_1.LocalProgrammingLanguageManifestNotFound(error, slug);
@@ -30,6 +40,25 @@ class ProgrammingLanguageManifestRepository extends resource_1.default {
     getSourceCodeFileName(programmingLanguageManifest) {
         return programmingLanguageManifest.programmingLanguage === 'JAVASCRIPT' ? 'package.json' : 'requirements.txt';
     }
+    /**
+     * The inherited dependencies of one language, collapsed into a single file the way inherited
+     * variables are (`variables.inherited.env`) rather than one file per parent: two versions of the
+     * same package cannot be installed side by side, so there is only ever one winner per name and
+     * the platform has already picked it.
+     */
+    getInheritedFileName(programmingLanguage) {
+        return exports.INHERITED_FILE_NAME[programmingLanguage];
+    }
+    getInheritedPath(programmingLanguage) {
+        return path.join(this._repositoryName, this.getInheritedFileName(programmingLanguage));
+    }
+    readInheritedDependencies(programmingLanguage) {
+        const inheritedPath = this.getInheritedPath(programmingLanguage);
+        if (!fs.existsSync(inheritedPath)) {
+            return [];
+        }
+        return (0, dependencies_1.dependenciesFromFile)(programmingLanguage, fs.readFileSync(inheritedPath).toString());
+    }
     getResourceDirectory(programmingLanguageManifest) {
         return this._repositoryName;
     }
@@ -40,6 +69,7 @@ class ProgrammingLanguageManifestRepository extends resource_1.default {
         await new Promise((resolve, reject) => {
             try {
                 fs.removeSync(this.getResourcePath(programmingLanguageManifest));
+                this.removeInheritedFile(programmingLanguageManifest.programmingLanguage);
                 this.removeDirectoryIfEmpty(this.getResourceDirectory(programmingLanguageManifest));
                 resolve(true);
             }
@@ -57,6 +87,26 @@ class ProgrammingLanguageManifestRepository extends resource_1.default {
     }
     async saveFiles(programmingLanguageManifest) {
         (0, file_utils_1.outputFileSyncIfChanged)(this.getResourcePath(programmingLanguageManifest), (0, dependencies_1.dependenciesToFile)(programmingLanguageManifest.programmingLanguage, programmingLanguageManifest.dependencies));
+        const { programmingLanguage, inheritedDependencies } = programmingLanguageManifest;
+        if (inheritedDependencies.length === 0) {
+            // The workspace stopped inheriting anything (a parent was removed, or emptied its manifest):
+            // a stale file would keep being installed locally and keep showing in `status`.
+            this.removeInheritedFile(programmingLanguage);
+            return;
+        }
+        // Read-only, like inherited locales and modules: these belong to a parent workspace, and
+        // editing one here would change nothing — declare the name in package.json to override it.
+        (0, file_utils_1.outputFileSyncIfChanged)(this.getInheritedPath(programmingLanguage), (0, dependencies_1.dependenciesToFile)(programmingLanguage, inheritedDependencies), {
+            readOnly: true,
+        });
+    }
+    removeInheritedFile(programmingLanguage) {
+        const inheritedPath = this.getInheritedPath(programmingLanguage);
+        if (fs.existsSync(inheritedPath)) {
+            // Written read-only, so it has to be made writable before it can go.
+            fs.chmodSync(inheritedPath, 0o644);
+            fs.removeSync(inheritedPath);
+        }
     }
     async metadataFromFiles(slug) {
         if (slug === 'JAVASCRIPT') {

package/dist/repositories/team.d.ts

@@ -17,14 +17,24 @@ export default class TeamRepository {
     /** Builds a Team from the cloud's raw settings, resolving the error-handler id to a slug. */
     fromRaw(raw: RawTeamSettings): Promise<Team>;
     /**
-     * Writes the cloud's team versions and aliases into the Team as the pull-only team.json
-     * fields (sorted for stable git diffs). These fields never enter the content hash and are
-     * stripped from pushes: all writes go through the team:versions/team:aliases commands.
+     * Writes the cloud's team versions and aliases into the Team as the team.json versioning
+     * fields (sorted for stable git diffs). Cloud entries always carry a createdAt; only
+     * hand-added local entries lack one, and those never pass through here.
      */
     applyCloudVersioning(team: Team, versions: TeamVersion[], aliases: TeamVersionAlias[]): void;
     resolveSlugToId(processSlug: string): Promise<string>;
     resolveIdToSlug(processId: string): Promise<string>;
     private parseErrorHandler;
+    /**
+     * team.json is hand-edited to declare versions, so entries without a tag are dropped and a
+     * duplicated tag keeps its first entry (a tag names one immutable snapshot).
+     */
+    private parseVersions;
+    /**
+     * An alias is a name->tag pointer; entries missing either half are dropped and a duplicated
+     * name keeps its first entry.
+     */
+    private parseAliases;
     /** A configuration without a variable key is meaningless, so it is read as absent. */
     private parseWebhookAuth;
     private toFile;

package/dist/repositories/team.js

@@ -30,12 +30,11 @@ class TeamRepository {
         catch { }
         const parentTeamSlugs = Array.isArray(raw.parentTeamSlugs) ? raw.parentTeamSlugs : [];
         const team = new types_1.Team(slug, parentTeamSlugs, raw.zoneId, this.parseErrorHandler(raw.errorHandlerConfig), this.parseWebhookAuth(raw.webhookAuth), typeof raw.primaryLocale === 'string' && raw.primaryLocale.length > 0 ? raw.primaryLocale : undefined);
-        // Parsed so a find()+save() round-trip does not drop the pull-only fields.
         if (Array.isArray(raw.versions)) {
-            team.versions = raw.versions;
+            team.versions = this.parseVersions(raw.versions);
         }
         if (Array.isArray(raw.aliases)) {
-            team.aliases = raw.aliases;
+            team.aliases = this.parseAliases(raw.aliases);
         }
         return team;
     }
@@ -54,9 +53,9 @@ class TeamRepository {
         return new types_1.Team(raw.slug, raw.parentTeamSlugs ?? [], raw.zoneId, errorHandlerConfig, this.parseWebhookAuth(raw.webhookAuth), raw.primaryLocale ?? undefined);
     }
     /**
-     * Writes the cloud's team versions and aliases into the Team as the pull-only team.json
-     * fields (sorted for stable git diffs). These fields never enter the content hash and are
-     * stripped from pushes: all writes go through the team:versions/team:aliases commands.
+     * Writes the cloud's team versions and aliases into the Team as the team.json versioning
+     * fields (sorted for stable git diffs). Cloud entries always carry a createdAt; only
+     * hand-added local entries lack one, and those never pass through here.
      */
     applyCloudVersioning(team, versions, aliases) {
         team.versions = versions
@@ -67,7 +66,7 @@ class TeamRepository {
             }
             return entry;
         })
-            .sort((a, b) => a.createdAt.localeCompare(b.createdAt));
+            .sort((a, b) => (a.createdAt ?? '').localeCompare(b.createdAt ?? ''));
         team.aliases = aliases
             .map((alias) => ({ name: alias.name, tag: alias.tag }))
             .sort((a, b) => a.name.localeCompare(b.name));
@@ -87,6 +86,50 @@ class TeamRepository {
         }
         return { processSlug: raw.processSlug, tag: raw.tag ?? null };
     }
+    /**
+     * team.json is hand-edited to declare versions, so entries without a tag are dropped and a
+     * duplicated tag keeps its first entry (a tag names one immutable snapshot).
+     */
+    parseVersions(raw) {
+        const versions = [];
+        for (const candidate of raw) {
+            if (!candidate || typeof candidate.tag !== 'string' || candidate.tag.length === 0) {
+                continue;
+            }
+            if (versions.some(({ tag }) => tag === candidate.tag)) {
+                continue;
+            }
+            const entry = { tag: candidate.tag };
+            if (typeof candidate.comment === 'string' && candidate.comment.length > 0) {
+                entry.comment = candidate.comment;
+            }
+            if (typeof candidate.createdAt === 'string' && candidate.createdAt.length > 0) {
+                entry.createdAt = candidate.createdAt;
+            }
+            versions.push(entry);
+        }
+        return versions;
+    }
+    /**
+     * An alias is a name->tag pointer; entries missing either half are dropped and a duplicated
+     * name keeps its first entry.
+     */
+    parseAliases(raw) {
+        const aliases = [];
+        for (const candidate of raw) {
+            if (!candidate || typeof candidate.name !== 'string' || candidate.name.length === 0) {
+                continue;
+            }
+            if (typeof candidate.tag !== 'string' || candidate.tag.length === 0) {
+                continue;
+            }
+            if (aliases.some(({ name }) => name === candidate.name)) {
+                continue;
+            }
+            aliases.push({ name: candidate.name, tag: candidate.tag });
+        }
+        return aliases;
+    }
     /** A configuration without a variable key is meaningless, so it is read as absent. */
     parseWebhookAuth(raw) {
         if (!raw || typeof raw.variableKey !== 'string' || raw.variableKey.length === 0) {
@@ -114,7 +157,7 @@ class TeamRepository {
         if (team.primaryLocale !== undefined) {
             file.primaryLocale = team.primaryLocale;
         }
-        // Pull-only global versioning fields, appended after the pushable settings.
+        // Global versioning fields, appended after the scalar settings.
         if (team.versions !== undefined) {
             file.versions = team.versions;
         }

package/dist/runtime/libs/python/fcode/context.py

@@ -81,22 +81,29 @@ class Processes(dict):
 class I18n:
     """Local equivalent of the cloud's fcode.i18n.
 
-    The CLI has already layered the chosen locale over the workspace's primary one, so what
-    arrives here is a single flat map. Nothing raises: a key with no translation resolves to the
-    key itself, and a placeholder with no argument is left exactly as written.
-
-    The ``options`` argument (the version a call pins in the cloud) is accepted and ignored: a
-    workspace directory holds no published snapshots, so a pinned call resolves against the files
-    on disk -- the same per-file fallback the cloud applies to a locale never published at that tag.
+    The CLI has already layered the chosen locale over the workspace's primary one, so the base
+    map that arrives here is flat. ``byLocale`` carries each locale's own files, so a call naming
+    a locale (``{"locale": "es"}``) resolves against that locale first and falls back key by key
+    to the base map, exactly like the cloud executors. Nothing raises: a key with no translation
+    resolves to the key itself, and a placeholder with no argument is left exactly as written.
+
+    The version a call pins in the cloud is accepted and ignored: a workspace directory holds no
+    published snapshots, so a pinned call resolves against the files on disk -- the same per-file
+    fallback the cloud applies to a locale never published at that tag.
     """
 
     def __init__(self, i18n_payload):
         payload = i18n_payload or {}
         self.__translations = payload.get("translations") or {}
+        self.__by_locale = payload.get("byLocale") or {}
         self.locale = payload.get("locale")
 
     def __call__(self, key, args=None, options=None):
-        template = self.__translations.get(key)
+        locale = options.get("locale") if isinstance(options, dict) else None
+        locale_map = self.__by_locale.get(str(locale)) if locale is not None else None
+        template = locale_map.get(key) if locale_map is not None else None
+        if template is None:
+            template = self.__translations.get(key)
         if template is None:
             return key
         if not isinstance(args, dict):

package/dist/services/fcode-graphql-client.d.ts

@@ -68,6 +68,7 @@ declare class FcodeGraphQLClient {
     team(): Promise<RawTeamSettings>;
     pushTeam(update: TeamUpdateInput): Promise<RawTeamSettings>;
     mapProgrammingLanguageManifest(programmingLanguageManifest: any): ProgrammingLanguageManifest;
+    private mapDependencies;
     allProgrammingLanguageManifest(): Promise<Array<ProgrammingLanguageManifest>>;
     pushProgrammingLanguageManifest(programmingLanguageManifest: ProgrammingLanguageManifest): Promise<ProgrammingLanguageManifest>;
     allServiceAccounts(): Promise<Array<ServiceAccount>>;

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
     }
@@ -429,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,
@@ -645,6 +671,13 @@ class FcodeGraphQLClient {
                 isNative
                 gitUrl
               }
+              inheritedDependencies {
+                name
+                semVer
+                isNative
+                gitUrl
+                resolvingTeamSlug
+              }
             }
           }
         `, { programmingLanguage })
@@ -654,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!) {
@@ -732,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));
     }
     /**
@@ -941,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 = [];
@@ -983,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-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-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.3.0"
+  "version": "2.4.0"
 }

package/package.json

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