@factorialco/fcode-cli 2.3.0 → 2.4.0

package/README.md

@@ -20,7 +20,7 @@ $ npm install -g @factorialco/fcode-cli
 $ fcode COMMAND
 running command...
 $ fcode (--version)
-@factorialco/fcode-cli/2.3.0 linux-x64 node-v22.22.3
+@factorialco/fcode-cli/2.4.0 linux-x64 node-v22.22.3
 $ fcode --help [COMMAND]
 USAGE
   $ fcode COMMAND
@@ -998,14 +998,17 @@ EXAMPLES
 
 ## `fcode team:pull`
 
-Fetch team settings (timezone, error handler, inheritance) from cloud into team.json
+Fetch team settings (timezone, error handler, inheritance) and team versions/aliases from cloud into team.json
 
 ```
 USAGE
-  $ fcode team:pull
+  $ fcode team:pull [-f]
+
+FLAGS
+  -f, --force  Force command
 
 DESCRIPTION
-  Fetch team settings (timezone, error handler, inheritance) from cloud into team.json
+  Fetch team settings (timezone, error handler, inheritance) and team versions/aliases from cloud into team.json
 
 EXAMPLES
   $ fcode team:pull
@@ -1013,7 +1016,7 @@ EXAMPLES
 
 ## `fcode team:push`
 
-Update cloud team settings (timezone, error handler, inheritance, webhook auth) from team.json
+Update cloud team settings (timezone, error handler, inheritance, webhook auth) and sync team versions/aliases from team.json
 
 ```
 USAGE
@@ -1023,7 +1026,8 @@ FLAGS
   -f, --force  Force command
 
 DESCRIPTION
-  Update cloud team settings (timezone, error handler, inheritance, webhook auth) from team.json
+  Update cloud team settings (timezone, error handler, inheritance, webhook auth) and sync team versions/aliases from
+  team.json
 
 EXAMPLES
   $ fcode team:push
@@ -1031,14 +1035,14 @@ EXAMPLES
 
 ## `fcode team:status`
 
-Show whether team settings (timezone, error handler, inheritance) differ from the cloud
+Show whether team settings (timezone, error handler, inheritance) or team versions/aliases differ from the cloud
 
 ```
 USAGE
   $ fcode team:status
 
 DESCRIPTION
-  Show whether team settings (timezone, error handler, inheritance) differ from the cloud
+  Show whether team settings (timezone, error handler, inheritance) or team versions/aliases differ from the cloud
 
 EXAMPLES
   $ fcode team:status

package/dist/commands/dependencies/status.d.ts

@@ -1,9 +1,20 @@
+import { table } from '../../utils/cli/styled/table';
 import DependencyCommand from '../../core/commands/dependency-command';
+import { type MergedResource } from '../../core/types';
+export declare const inheritedCount: (resource: MergedResource) => number;
+/**
+ * A manifest is never itself inherited — every workspace owns one per language — so the column
+ * counts the entries its parents contribute rather than naming one workspace the way the other
+ * `status` commands do. Empty when nothing is inherited, so the column is dropped entirely, like
+ * theirs.
+ */
+export declare const inheritedColumn: (resources: Array<MergedResource>) => table.Columns<MergedResource>;
 export default class DependenciesStatus extends DependencyCommand {
     static description: string;
     static examples: string[];
     static args: {
         resourceSlug: import("@oclif/core/lib/interfaces").Arg<string | undefined, Record<string, unknown>>;
     };
+    resourcesTableLog(resources: Array<MergedResource>): Promise<void>;
     run(): Promise<void>;
 }

package/dist/commands/dependencies/status.js

@@ -1,8 +1,51 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.inheritedColumn = exports.inheritedCount = void 0;
+const cli_1 = require("../../utils/cli");
 const dependency_command_1 = require("../../core/commands/dependency-command");
 const types_1 = require("../../core/types");
+const colorize_resource_1 = require("../../utils/colorize-resource");
+const inheritedCount = (resource) => resource.inheritedDependencies?.length ?? 0;
+exports.inheritedCount = inheritedCount;
+/**
+ * A manifest is never itself inherited — every workspace owns one per language — so the column
+ * counts the entries its parents contribute rather than naming one workspace the way the other
+ * `status` commands do. Empty when nothing is inherited, so the column is dropped entirely, like
+ * theirs.
+ */
+const inheritedColumn = (resources) => {
+    if (!resources.some((resource) => (0, exports.inheritedCount)(resource) > 0)) {
+        return {};
+    }
+    return {
+        inherited: {
+            get(resource) {
+                const count = (0, exports.inheritedCount)(resource);
+                return (0, colorize_resource_1.colorizeByStatus)(count > 0 ? `🔗 ${count}` : '', resource.status);
+            },
+            header: 'inherited',
+        },
+    };
+};
+exports.inheritedColumn = inheritedColumn;
 class DependenciesStatus extends dependency_command_1.default {
+    async resourcesTableLog(resources) {
+        cli_1.cli.table(resources, {
+            name: {
+                get({ slug, status }) {
+                    return (0, colorize_resource_1.colorizeByStatus)(slug, status);
+                },
+                header: 'name',
+            },
+            ...(0, exports.inheritedColumn)(resources),
+            status: {
+                get({ status }) {
+                    return (0, colorize_resource_1.colorizeByStatus)(status, status);
+                },
+                header: 'status',
+            },
+        }, { sort: 'name' });
+    }
     async run() {
         await this.resourcesLog();
     }

package/dist/commands/pull.js

@@ -23,7 +23,7 @@ class PullCommand extends base_command_1.default {
         await pull_5.default.run(args);
         // Team settings are pulled last so process metadata is available to resolve the
         // error-handler process id to its slug.
-        await pull_6.default.run([]);
+        await pull_6.default.run(args);
         // Keep inherited resources out of git now that all resource metadata is saved.
         await (0, gitignore_1.syncInheritedGitignore)();
     }

package/dist/commands/team/pull.d.ts

@@ -3,6 +3,9 @@ import TeamRepository from '../../repositories/team';
 export default class TeamPullCommand extends ApiClientCommand {
     static description: string;
     static examples: string[];
+    static flags: {
+        force: import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
+    };
     _teamRepository: TeamRepository;
     run(): Promise<void>;
 }

package/dist/commands/team/pull.js

@@ -3,6 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 const color_1 = require("@oclif/color");
 const api_client_command_1 = require("../../core/commands/api-client-command");
 const team_1 = require("../../repositories/team");
+const types_1 = require("../../core/types");
 const cli_1 = require("../../utils/cli");
 class TeamPullCommand extends api_client_command_1.default {
     constructor() {
@@ -10,8 +11,19 @@ class TeamPullCommand extends api_client_command_1.default {
         this._teamRepository = new team_1.default();
     }
     async run() {
-        await this.parse(TeamPullCommand);
+        const { flags: { force }, } = await this.parse(TeamPullCommand);
         cli_1.default.log(color_1.default.cyan('\n🗄️  pulling team settings...'));
+        // Local edits (a version tag added, an alias re-pointed) would be silently wiped by the
+        // overwrite below, so an unpushed team.json blocks the pull. No stored hash means there is
+        // no baseline to have diverged from (fresh workspace), so the pull proceeds.
+        if (!force && this._teamRepository.exists()) {
+            const local = await this._teamRepository.find();
+            const storedHash = await this.workspaceConfig.getTeamStoredHash();
+            if (storedHash !== undefined && storedHash !== local.contentHash) {
+                cli_1.default.log(color_1.default.yellow('🔺 team.json has unpushed local changes — run fcode team:push first, or fcode team:pull --force to overwrite them'));
+                return;
+            }
+        }
         const [raw, versions, aliases] = await Promise.all([
             this._fcodeGraphQLClient.team(),
             this._fcodeGraphQLClient.allTeamVersions(),
@@ -20,11 +32,10 @@ class TeamPullCommand extends api_client_command_1.default {
         const team = await this._teamRepository.fromRaw(raw);
         this._teamRepository.applyCloudVersioning(team, versions, aliases);
         this._teamRepository.save(team);
-        // The stored hash intentionally excludes versions/aliases (see Team.contentHash), so
-        // pull-only fields never surface as a phantom MODIFIED state.
         await this.workspaceConfig.setTeamStoredHash(team.contentHash);
     }
 }
-TeamPullCommand.description = 'Fetch team settings (timezone, error handler, inheritance) from cloud into team.json';
+TeamPullCommand.description = 'Fetch team settings (timezone, error handler, inheritance) and team versions/aliases from cloud into team.json';
 TeamPullCommand.examples = ['$ fcode team:pull'];
+TeamPullCommand.flags = types_1.ForceFlag;
 exports.default = TeamPullCommand;

package/dist/commands/team/push.d.ts

@@ -8,4 +8,6 @@ export default class TeamPushCommand extends ApiClientCommand {
     };
     _teamRepository: TeamRepository;
     run(): Promise<void>;
+    /** Makes the cloud's team versions/aliases match team.json; returns failed manifest entries. */
+    private syncVersioning;
 }

package/dist/commands/team/push.js

@@ -4,6 +4,7 @@ const color_1 = require("@oclif/color");
 const api_client_command_1 = require("../../core/commands/api-client-command");
 const team_1 = require("../../repositories/team");
 const types_1 = require("../../core/types");
+const team_versioning_1 = require("../../services/team-versioning");
 const cli_1 = require("../../utils/cli");
 class TeamPushCommand extends api_client_command_1.default {
     constructor() {
@@ -22,9 +23,6 @@ class TeamPushCommand extends api_client_command_1.default {
             cli_1.default.log('Team settings already up to date');
             return;
         }
-        // team.json's `versions`/`aliases` fields are pull-only and intentionally left out of the
-        // update payload: team versions and aliases are only written through the explicit
-        // team:versions/team:aliases commands.
         const update = { parentTeamSlugs: team.parentTeamSlugs };
         if (team.zoneId !== undefined) {
             update.zoneId = team.zoneId;
@@ -42,11 +40,64 @@ class TeamPushCommand extends api_client_command_1.default {
         // so removing primaryLocale from it must clear the cloud setting. Empty string is the clear.
         update.primaryLocale = team.primaryLocale ?? '';
         await this._fcodeGraphQLClient.pushTeam(update);
+        const failedEntities = await this.syncVersioning(team, force);
+        // Re-read the cloud state so server-assigned fields (createdAt) and declined deletions
+        // land back in team.json, then hash exactly what was written.
+        const [versions, aliases] = await Promise.all([
+            this._fcodeGraphQLClient.allTeamVersions(),
+            this._fcodeGraphQLClient.allTeamVersionAliases(),
+        ]);
+        this._teamRepository.applyCloudVersioning(team, versions, aliases);
+        this._teamRepository.save(team);
         await this.workspaceConfig.setTeamStoredHash(team.contentHash);
         cli_1.default.log(color_1.default.green('✅ team settings pushed'));
+        // Release pipelines must be able to detect an incomplete version. Re-running the
+        // command converges: it publishes only what is still missing.
+        if (failedEntities > 0) {
+            this.error(`team versions pushed with ${failedEntities} failed entities`, { exit: 1 });
+        }
+    }
+    /** Makes the cloud's team versions/aliases match team.json; returns failed manifest entries. */
+    async syncVersioning(team, force) {
+        const [cloudVersions, cloudAliases] = await Promise.all([
+            this._fcodeGraphQLClient.allTeamVersions(),
+            this._fcodeGraphQLClient.allTeamVersionAliases(),
+        ]);
+        const plan = (0, team_versioning_1.planTeamVersioningSync)(team, cloudVersions, cloudAliases);
+        if ((0, team_versioning_1.teamVersioningSyncPlanIsEmpty)(plan)) {
+            return 0;
+        }
+        let failedEntities = 0;
+        for (const version of plan.createVersions) {
+            cli_1.default.log(color_1.default.cyan(`🏷️  publishing team version ${version.tag}...`));
+            const teamVersion = await this._fcodeGraphQLClient.createTeamVersion(version.tag, version.comment);
+            failedEntities += (0, team_versioning_1.logTeamVersionManifest)(teamVersion);
+        }
+        for (const version of plan.deleteVersions) {
+            if (!force) {
+                const confirmed = await cli_1.default.confirm(`Team version ${version.tag} exists in the cloud but not in team.json. Deleting it also deletes ` +
+                    'every process/module version with that tag, plus the aliases, executions and schedules ' +
+                    'referencing them. Delete it?');
+                if (!confirmed) {
+                    continue;
+                }
+            }
+            cli_1.default.log(color_1.default.cyan(`🗑️  deleting team version ${version.tag}...`));
+            await this._fcodeGraphQLClient.deleteTeamVersion(version.tag);
+        }
+        for (const alias of plan.setAliases) {
+            cli_1.default.log(color_1.default.cyan(`🔗 pointing alias ${alias.name} at ${alias.tag}...`));
+            await this._fcodeGraphQLClient.createTeamVersionAlias(alias.name, alias.tag);
+        }
+        for (const alias of plan.deleteAliases) {
+            cli_1.default.log(color_1.default.cyan(`🗑️  deleting alias ${alias.name}...`));
+            await this._fcodeGraphQLClient.deleteTeamVersionAlias(alias.id);
+        }
+        return failedEntities;
     }
 }
-TeamPushCommand.description = 'Update cloud team settings (timezone, error handler, inheritance, webhook auth) from team.json';
+TeamPushCommand.description = 'Update cloud team settings (timezone, error handler, inheritance, webhook auth) and sync ' +
+    'team versions/aliases from team.json';
 TeamPushCommand.examples = ['$ fcode team:push'];
 TeamPushCommand.flags = types_1.ForceFlag;
 exports.default = TeamPushCommand;

package/dist/commands/team/status.js

@@ -18,7 +18,13 @@ class TeamStatusCommand extends api_client_command_1.default {
         }
         const local = await this._teamRepository.find();
         const storedHash = await this.workspaceConfig.getTeamStoredHash();
-        const remote = await this._teamRepository.fromRaw(await this._fcodeGraphQLClient.team());
+        const [raw, versions, aliases] = await Promise.all([
+            this._fcodeGraphQLClient.team(),
+            this._fcodeGraphQLClient.allTeamVersions(),
+            this._fcodeGraphQLClient.allTeamVersionAliases(),
+        ]);
+        const remote = await this._teamRepository.fromRaw(raw);
+        this._teamRepository.applyCloudVersioning(remote, versions, aliases);
         const localChanged = storedHash !== local.contentHash;
         const remoteChanged = storedHash !== remote.contentHash;
         if (localChanged && remoteChanged) {
@@ -35,6 +41,6 @@ class TeamStatusCommand extends api_client_command_1.default {
         }
     }
 }
-TeamStatusCommand.description = 'Show whether team settings (timezone, error handler, inheritance) differ from the cloud';
+TeamStatusCommand.description = 'Show whether team settings (timezone, error handler, inheritance) or team versions/aliases differ from the cloud';
 TeamStatusCommand.examples = ['$ fcode team:status'];
 exports.default = TeamStatusCommand;

package/dist/commands/team/versions/create.d.ts

@@ -9,5 +9,4 @@ export default class TeamVersionsCreateCommand extends ApiClientCommand {
         comment: import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
     };
     run(): Promise<void>;
-    private logManifest;
 }

package/dist/commands/team/versions/create.js

@@ -4,13 +4,14 @@ const core_1 = require("@oclif/core");
 const color_1 = require("@oclif/color");
 const api_client_command_1 = require("../../../core/commands/api-client-command");
 const pull_1 = require("../../pull");
+const team_versioning_1 = require("../../../services/team-versioning");
 const cli_1 = require("../../../utils/cli");
 class TeamVersionsCreateCommand extends api_client_command_1.default {
     async run() {
         const { args: { tag }, flags: { comment }, } = await this.parse(TeamVersionsCreateCommand);
         cli_1.default.log(color_1.default.cyan(`\n🏷️  publishing team version ${tag}...`));
         const teamVersion = await this._fcodeGraphQLClient.createTeamVersion(tag, comment);
-        const failedCount = this.logManifest(teamVersion);
+        const failedCount = (0, team_versioning_1.logTeamVersionManifest)(teamVersion);
         // Refresh the local workspace: per-entity versions/<tag>/ folders and team.json.
         await pull_1.default.run([]);
         // Release pipelines must be able to detect an incomplete version. Re-running the
@@ -19,16 +20,6 @@ class TeamVersionsCreateCommand extends api_client_command_1.default {
             this.error(`team version ${tag} published with ${failedCount} failed entities`, { exit: 1 });
         }
     }
-    logManifest(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;
-    }
 }
 TeamVersionsCreateCommand.description = 'Publish a team version: creates a version with the tag on every owned process and module ' +
     '(existing tags are skipped) and pins bare module imports in the published snapshots';

package/dist/core/dependencies/env-dependencies-command.js

@@ -25,7 +25,10 @@ class EnvDependenciesCommand extends api_client_command_1.default {
             fs.rmSync(this.envPath, { recursive: true });
         }
         const manifest = await this.getManifest();
-        const installationPath = this.installationPath(manifest.dependencies);
+        // The effective set — own dependencies over inherited ones — because that is what the platform
+        // installs, and the directory is named after the hash of what is installed.
+        const dependencies = manifest.effectiveDependencies;
+        const installationPath = this.installationPath(dependencies);
         if (fs.existsSync(installationPath)) {
             if (force) {
                 fs.rmSync(installationPath, { recursive: true });
@@ -38,12 +41,12 @@ class EnvDependenciesCommand extends api_client_command_1.default {
         await this.createEnv();
         cli_1.default.log(`Installing Factorial Code ${(0, types_1.programmingLanguageDisplayName)(this.programmingLanguage)} dependencies... (This process might take some time ⌛️)`);
         cli_1.default.log('====================================');
-        await this.installDependencies(installationPath, manifest.dependencies);
+        await this.installDependencies(installationPath, dependencies);
         cli_1.default.log('====================================');
         cli_1.default.log(color_1.default.green(`Factorial Code ${(0, types_1.programmingLanguageDisplayName)(this.programmingLanguage)} dependencies successfully installed in ${installationPath} 🤩\n\n`));
     }
     async check() {
-        const installationPath = this.installationPath((await this.getManifest()).dependencies);
+        const installationPath = this.installationPath((await this.getManifest()).effectiveDependencies);
         if (!fs.existsSync(installationPath)) {
             cli_1.default.log(color_1.default.yellow(`⚠️  ${(0, types_1.programmingLanguageDisplayName)(this.programmingLanguage)} dependencies need to be installed.`));
         }

package/dist/core/executors/javascript-execution-task.js

@@ -593,13 +593,22 @@ const main = typeof _hooksModule['${fn}'] === 'function'
             }
           };
         })(),
-        // The third argument is the version options the cloud honours. 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 that was never published at that tag.
+        // 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 that was
+        // never published at that tag. A locale option resolves against that locale's own files,
+        // falling back key by key to the merged translations, exactly like the cloud executors.
         // Own properties only and no array arguments, exactly like the cloud executors.
-        i18n: Object.assign((key, args, _options) => {
+        i18n: Object.assign((key, args, options) => {
           const translations = ${JSON.stringify(metadata.i18n.translations, null, 2)};
-          const template = Object.hasOwn(translations, key) ? translations[key] : undefined;
+          const byLocale = ${JSON.stringify(metadata.i18n.byLocale, null, 2)};
+          const requested = options && typeof options === 'object' && options.locale !== undefined && options.locale !== null
+            ? String(options.locale)
+            : undefined;
+          const localeMap = requested !== undefined && Object.hasOwn(byLocale, requested) ? byLocale[requested] : undefined;
+          let template = localeMap && Object.hasOwn(localeMap, key) ? localeMap[key] : undefined;
+          if (template === undefined) {
+            template = Object.hasOwn(translations, key) ? translations[key] : undefined;
+          }
           if (template === undefined) {
             return key;
           }

package/dist/core/types.d.ts

@@ -130,12 +130,30 @@ export interface ProcessForm {
     appRole?: AppRole;
     authMode?: FormAuthMode;
 }
+export interface ProcessUiTrigger {
+    enabled: boolean;
+    /** Identifier of the UI location the trigger is rendered in. */
+    locationId?: string;
+    /**
+     * Label shown on the trigger. May contain fcode.i18n("key") tokens, which the platform
+     * resolves when a process listing names a locale.
+     */
+    label?: string;
+    /** f0 icon name, e.g. "Globe". */
+    icon?: string;
+    /**
+     * When true the trigger executes the process synchronously and returns the result
+     * envelope; otherwise the execution is fire-and-forget.
+     */
+    awaitResult?: boolean;
+}
 export interface ProcessMetadataFields {
     name: string;
     description?: string;
     tags: string[];
     webhook?: ProcessWebhook;
     form?: ProcessForm;
+    uiTrigger?: ProcessUiTrigger;
 }
 export declare class Process extends Resource {
     id: string;
@@ -146,6 +164,7 @@ export declare class Process extends Resource {
     tags: string[];
     webhook?: ProcessWebhook;
     form?: ProcessForm;
+    uiTrigger?: ProcessUiTrigger;
     script: {
         parametersSchema: any;
         programmingLanguage: ProgrammingLanguage;
@@ -238,7 +257,14 @@ export declare class ProgrammingLanguageManifest extends Resource {
     slug: string;
     programmingLanguage: ProgrammingLanguage;
     dependencies: Array<Dependency>;
-    constructor(id: string, slug: string, programmingLanguage: ProgrammingLanguage, dependencies: Array<Dependency>);
+    inheritedDependencies: Array<Dependency>;
+    constructor(id: string, slug: string, programmingLanguage: ProgrammingLanguage, dependencies: Array<Dependency>, inheritedDependencies?: Array<Dependency>);
+    /**
+     * What an execution installs: this workspace's dependencies layered over the inherited ones, one
+     * entry per package name. Mirrors the platform's merge so a local run resolves the same install
+     * directory the cloud does.
+     */
+    get effectiveDependencies(): Array<Dependency>;
     get contentHash(): string;
 }
 export interface ErrorHandlerConfig {
@@ -273,7 +299,7 @@ export interface TeamVersionAlias {
 export interface TeamVersionFileEntry {
     tag: string;
     comment?: string;
-    createdAt: string;
+    createdAt?: string;
 }
 export interface TeamAliasFileEntry {
     name: string;
@@ -363,6 +389,7 @@ export declare const DependenciesFlags: {
 export declare class Dependency {
     name: string;
     specifier: string;
+    resolvingTeamSlug?: string;
 }
 export declare class ServiceAccount extends Resource {
     id: string;

package/dist/core/types.js

@@ -49,6 +49,7 @@ class Process extends Resource {
         this.tags = metadata.tags;
         this.webhook = metadata.webhook;
         this.form = metadata.form;
+        this.uiTrigger = metadata.uiTrigger;
         this.script = script;
         this.readme = readme;
         this.manifest = settings.dependencies.scopedToProcess && manifest !== null ? manifest : { dependencies: [] };
@@ -65,6 +66,9 @@ class Process extends Resource {
             tags: this.tags || [],
             webhook: this.webhook || null,
             form: this.form || null,
+            // Inserted only when set, so every process that predates UI triggers keeps the
+            // content hash already stored in .fcode (mirrors Team.contentHash).
+            ...(this.uiTrigger && { uiTrigger: this.uiTrigger }),
             manifestDependencies: this.manifest.dependencies,
             dependenciesScopedToProcess: this.settings.dependencies.scopedToProcess,
         });
@@ -185,12 +189,22 @@ exports.Variable = Variable;
 Variable.ENV_KEY_MAX_LENGTH = 64;
 Variable.ENV_KEY_REGEX = /^[A-Z_a-z]\w*$/;
 class ProgrammingLanguageManifest extends Resource {
-    constructor(id, slug, programmingLanguage, dependencies) {
+    constructor(id, slug, programmingLanguage, dependencies, inheritedDependencies = []) {
         super();
         this.id = id;
         this.slug = slug;
         this.programmingLanguage = programmingLanguage;
         this.dependencies = dependencies;
+        this.inheritedDependencies = inheritedDependencies;
+    }
+    /**
+     * What an execution installs: this workspace's dependencies layered over the inherited ones, one
+     * entry per package name. Mirrors the platform's merge so a local run resolves the same install
+     * directory the cloud does.
+     */
+    get effectiveDependencies() {
+        const ownNames = new Set(this.dependencies.map((dependency) => dependency.name));
+        return [...this.dependencies, ...this.inheritedDependencies.filter((dependency) => !ownNames.has(dependency.name))];
     }
     get contentHash() {
         return crypto
@@ -229,6 +243,18 @@ class Team extends Resource {
         if (this.primaryLocale) {
             payload.primaryLocale = this.primaryLocale;
         }
+        // Versions hash only their tags and aliases their name->tag pairs: createdAt is
+        // server-assigned and a comment is immutable once published (there is no update mutation),
+        // so neither can represent a pushable local change. Inserted only when non-empty, again to
+        // keep hashes stored before versioning existed valid.
+        if (this.versions && this.versions.length > 0) {
+            payload.versions = this.versions.map(({ tag }) => tag).sort();
+        }
+        if (this.aliases && this.aliases.length > 0) {
+            payload.aliases = this.aliases
+                .map(({ name, tag }) => ({ name, tag }))
+                .sort((a, b) => a.name.localeCompare(b.name));
+        }
         return (0, canonical_hash_1.canonicalJsonHash)(payload);
     }
 }

package/dist/core/utils/dependencies.js

@@ -12,7 +12,10 @@ async function getDependenciesPath(programmingLanguage) {
     const basePath = (0, workspace_1.baseDependenciesPath)(programmingLanguage);
     const repo = new programming_language_manifest_1.default();
     const programmingLanguageManifest = await repo.find(programmingLanguage);
-    const dependenciesDirectory = (0, env_dependencies_command_1.dependenciesHash)(programmingLanguageManifest.dependencies);
+    // The effective set, not the workspace's own: the cloud installs the inherited dependencies too,
+    // and the directory is named after the hash of what is installed. Hashing only the own list here
+    // would make a local run resolve a different directory than the platform.
+    const dependenciesDirectory = (0, env_dependencies_command_1.dependenciesHash)(programmingLanguageManifest.effectiveDependencies);
     return path.join(basePath, dependenciesDirectory);
 }
 function getProcessDependenciesPath(process) {

package/dist/env.js

@@ -14,7 +14,7 @@ const zod_1 = require("zod");
  */
 exports.envSchema = zod_1.z.object({
     // --- Cloud / auth endpoints ---
-    FCODE_CLOUD_URL: zod_1.z.string().min(1).default('https://code.factorial.dev/platform'),
+    FCODE_CLOUD_URL: zod_1.z.string().min(1).default('https://code.factorialhr.com/platform'),
     FCODE_AUTH_URL: zod_1.z.string().min(1).optional(),
     FCODE_CLIENT_ID: zod_1.z.string().min(1).default('cli'),
     // --- Local config location (defaults to os.homedir() at the call site) ---

package/dist/repositories/process.js

@@ -136,6 +136,7 @@ class ProcessRepository extends resource_1.default {
                 tags: Array.isArray(raw.tags) ? raw.tags : [],
                 webhook: raw.webhook,
                 form: raw.form,
+                uiTrigger: raw.uiTrigger,
             };
         }
         catch (error) {
@@ -156,6 +157,9 @@ class ProcessRepository extends resource_1.default {
         if (process.form !== undefined) {
             metadata.form = process.form;
         }
+        if (process.uiTrigger !== undefined) {
+            metadata.uiTrigger = process.uiTrigger;
+        }
         return metadata;
     }
     async findParameters(processSlug) {

package/dist/repositories/programming-language-manifest.d.ts

@@ -1,14 +1,30 @@
-import { ResourceMetadata, ProgrammingLanguageManifest } from '../core/types';
+import { ProgrammingLanguage, ProgrammingLanguageManifest, ResourceMetadata } from '../core/types';
 import ResourceRepositoryBase from './resource';
+/**
+ * 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.
+ */
+export declare const INHERITED_FILE_NAME: Record<ProgrammingLanguage, string>;
+export declare const DEPENDENCIES_DIR = "dependencies";
 declare class ProgrammingLanguageManifestRepository extends ResourceRepositoryBase<ProgrammingLanguageManifest> {
     constructor();
     find(slug: string): Promise<ProgrammingLanguageManifest>;
     protected getSourceCodeFileName(programmingLanguageManifest: ProgrammingLanguageManifest): string;
+    /**
+     * 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.
+     */
+    protected getInheritedFileName(programmingLanguage: ProgrammingLanguage): string;
+    getInheritedPath(programmingLanguage: ProgrammingLanguage): string;
+    private readInheritedDependencies;
     protected getResourceDirectory(programmingLanguageManifest: ProgrammingLanguageManifest): string;
     protected getResourcePath(programmingLanguageManifest: ProgrammingLanguageManifest): string;
     protected removeFiles(programmingLanguageManifest: ProgrammingLanguageManifest): Promise<void>;
     protected resourceToMetadata(programmingLanguageManifest: ProgrammingLanguageManifest): ResourceMetadata;
     protected saveFiles(programmingLanguageManifest: ProgrammingLanguageManifest): Promise<void>;
+    private removeInheritedFile;
     metadataFromFiles(slug: string): Promise<ResourceMetadata>;
     validSlug(slug: string): boolean;
     slugFormatMessage(): string;