@factorialco/fcode-cli 2.3.0 → 3.0.0

package/dist/core/commands/modules-command.js

@@ -4,6 +4,7 @@ const script_library_1 = require("../../repositories/script-library");
 const resource_merger_1 = require("../resource-merger");
 const resource_pusher_1 = require("../resource-pusher");
 const resource_command_1 = require("./resource-command");
+const resource_differ_1 = require("../../services/resource-differ");
 class ModulesCommand extends resource_command_1.default {
     async init() {
         await super.init();
@@ -11,6 +12,7 @@ class ModulesCommand extends resource_command_1.default {
         this._resourceMerger = new resource_merger_1.default(this._resourceRepository);
         this._resourcePusher = new resource_pusher_1.default(this._resourceRepository, this._fcodeGraphQLClient);
         this._resourceQuery = () => this._fcodeGraphQLClient.allScriptLibraries.bind(this._fcodeGraphQLClient)();
+        this._diffFilesFor = resource_differ_1.moduleDiffFiles;
         this._versionedResourceQuery = (id) => this._fcodeGraphQLClient.allVersionedScriptLibraries.bind(this._fcodeGraphQLClient)(id);
         this._pushVersionedResourceMutation = (versionedScriptLibrary) => this._fcodeGraphQLClient.createVersionedScriptLibrary.bind(this._fcodeGraphQLClient)(versionedScriptLibrary);
     }

package/dist/core/commands/processes-command.js

@@ -5,6 +5,7 @@ const process_1 = require("../../repositories/process");
 const resource_merger_1 = require("../resource-merger");
 const resource_pusher_1 = require("../resource-pusher");
 const resource_command_1 = require("./resource-command");
+const resource_differ_1 = require("../../services/resource-differ");
 class ProcessesCommand extends resource_command_1.default {
     async init() {
         await super.init();
@@ -12,6 +13,7 @@ class ProcessesCommand extends resource_command_1.default {
         this._resourceMerger = new resource_merger_1.default(this._resourceRepository);
         this._resourcePusher = new resource_pusher_1.default(this._resourceRepository, this._fcodeGraphQLClient);
         this._resourceQuery = () => this._fcodeGraphQLClient.allProcesses.bind(this._fcodeGraphQLClient)();
+        this._diffFilesFor = resource_differ_1.processDiffFiles;
         this._versionedResourceQuery = (id) => this._fcodeGraphQLClient.allVersionedProcesses.bind(this._fcodeGraphQLClient)(id);
         this._pushVersionedResourceMutation = (versionedProcess) => this._fcodeGraphQLClient.createVersionedProcesses.bind(this._fcodeGraphQLClient)(versionedProcess);
     }

package/dist/core/commands/resource-command.d.ts

@@ -1,12 +1,22 @@
-import type { AddResourceOptions, MergedResource, Resource } from '../types';
+import { ResourceStatus, type AddResourceOptions, type MergedResource, type Resource } from '../types';
 import ResourceRepositoryBase from '../../repositories/resource';
 import ResourceMerger from '../resource-merger';
 import ResourcePusher from '../resource-pusher';
 import ApiClientCommand from './api-client-command';
+import { PseudoFile } from '../../utils/diff';
+import { DiffSection, ResourcePair } from '../../services/resource-differ';
+/** A status meaning the two sides agree, so there is nothing to pull, push or diff. */
+export declare const isUnchangedStatus: (status: ResourceStatus) => boolean;
+/**
+ * An inherited resource the parent workspace owns and the cloud agrees on is noise in `status`:
+ * there is nothing to pull or push. It comes back as soon as it differs — or with --showInherited.
+ */
+export declare const isUnchangedInherited: (resource: MergedResource) => boolean;
 export default abstract class ResourceCommand<R extends Resource> extends ApiClientCommand {
     _resourceMerger: ResourceMerger<R>;
     _resourcePusher: ResourcePusher<R>;
     _resourceQuery: () => Promise<Array<R>>;
+    _diffFilesFor: (pair: ResourcePair<R>) => Array<PseudoFile>;
     _resourceRepository: ResourceRepositoryBase<R>;
     protected resourceSlug: string;
     protected filterResource: (slug: string) => boolean;
@@ -20,5 +30,20 @@ export default abstract class ResourceCommand<R extends Resource> extends ApiCli
     removeResource(slug: string): Promise<void>;
     pushResources(): Promise<void>;
     resourcesLog(): Promise<void>;
+    /**
+     * One heading per resource, so a patch is always attributable to a slug and its status. Variables
+     * override this: they share a single .env file, and one patch over it reads better than one per key.
+     *
+     * `allPairs` carries every resource, including the unchanged ones, for a renderer that needs the
+     * whole set to place a change in context; `diffable` is only what a status says has changed.
+     */
+    protected diffSections(diffable: Array<ResourcePair<R>>, allPairs: Array<ResourcePair<R>>): Array<DiffSection>;
+    /** Names the resource a patch belongs to, flagging an inherited one as the parent's to fix. */
+    protected diffLabel(pair: ResourcePair<R>): string;
+    /**
+     * Prints a unified diff of everything that differs between the workspace and the cloud, and
+     * reports whether anything did — which is what makes `fcode diff` exit non-zero.
+     */
+    resourcesDiff(): Promise<boolean>;
     resourcesTableLog(resources: Array<MergedResource>): Promise<void>;
 }

package/dist/core/commands/resource-command.js

@@ -1,9 +1,25 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.isUnchangedInherited = exports.isUnchangedStatus = void 0;
 const color_1 = require("@oclif/color");
 const cli_1 = require("../../utils/cli");
+const types_1 = require("../types");
 const api_client_command_1 = require("./api-client-command");
 const colorize_resource_1 = require("../../utils/colorize-resource");
+const diff_1 = require("../../utils/diff");
+const resource_differ_1 = require("../../services/resource-differ");
+// A sensitive variable never compares equal — its content hash is empty — so SENSITIVE is the
+// resting state of an inherited secret, not a change, and counts as unchanged here.
+const UNCHANGED_STATUSES = new Set([types_1.ResourceStatus.UP_TO_DATE, types_1.ResourceStatus.SENSITIVE]);
+/** A status meaning the two sides agree, so there is nothing to pull, push or diff. */
+const isUnchangedStatus = (status) => UNCHANGED_STATUSES.has(status);
+exports.isUnchangedStatus = isUnchangedStatus;
+/**
+ * An inherited resource the parent workspace owns and the cloud agrees on is noise in `status`:
+ * there is nothing to pull or push. It comes back as soon as it differs — or with --showInherited.
+ */
+const isUnchangedInherited = (resource) => Boolean(resource.resolvingTeamSlug) && (0, exports.isUnchangedStatus)(resource.status);
+exports.isUnchangedInherited = isUnchangedInherited;
 class ResourceCommand extends api_client_command_1.default {
     constructor() {
         super(...arguments);
@@ -60,18 +76,99 @@ class ResourceCommand extends api_client_command_1.default {
     async resourcesLog() {
         cli_1.default.log(color_1.default.cyan(`\n${this._resourceRepository._repositoryName} status`));
         const mergedResources = await this._resourceMerger.mergeStatus(await this.getRemoteResources(), await this.getLocalResources());
-        if (mergedResources.length > 0) {
-            await this.resourcesTableLog(mergedResources);
+        const { flags: { showInherited }, } = await this.parse(this.ctor);
+        const visibleResources = showInherited ? mergedResources : mergedResources.filter((resource) => !(0, exports.isUnchangedInherited)(resource));
+        const hiddenCount = mergedResources.length - visibleResources.length;
+        if (visibleResources.length > 0) {
+            await this.resourcesTableLog(visibleResources);
         }
-        else {
+        else if (mergedResources.length === 0) {
             cli_1.default.log(`No ${this._resourceRepository._repositoryName} found`);
         }
+        if (hiddenCount > 0) {
+            cli_1.default.log(color_1.default.cyan(`ℹ️  ${hiddenCount} inherited ${this._resourceRepository._repositoryName} up to date (hidden). Use --showInherited to list them.`));
+        }
         const slugsNotAdded = await this.findSlugsNotAdded();
         if (slugsNotAdded.length > 0) {
             const warningText = `\nℹ️  ${slugsNotAdded.length} ${this._resourceRepository._repositoryName} only existing in local: ${slugsNotAdded.join(', ')}\n   Use command 'fcode ${this._resourceRepository._repositoryName}:add' to keep track of these resources`;
             cli_1.default.log(color_1.default.yellow(warningText));
         }
     }
+    /**
+     * One heading per resource, so a patch is always attributable to a slug and its status. Variables
+     * override this: they share a single .env file, and one patch over it reads better than one per key.
+     *
+     * `allPairs` carries every resource, including the unchanged ones, for a renderer that needs the
+     * whole set to place a change in context; `diffable` is only what a status says has changed.
+     */
+    diffSections(diffable, allPairs) {
+        return diffable.map((pair) => ({
+            label: this.diffLabel(pair),
+            files: this._diffFilesFor(pair),
+        }));
+    }
+    /** Names the resource a patch belongs to, flagging an inherited one as the parent's to fix. */
+    diffLabel(pair) {
+        const label = `${pair.status} ${this._resourceRepository._repositoryName}/${pair.slug}`;
+        const inheritedTeam = (0, resource_differ_1.inheritedFrom)(pair);
+        return inheritedTeam ? `${label}  🔗 inherited from '${inheritedTeam}' (read-only — run pull to update)` : label;
+    }
+    /**
+     * Prints a unified diff of everything that differs between the workspace and the cloud, and
+     * reports whether anything did — which is what makes `fcode diff` exit non-zero.
+     */
+    async resourcesDiff() {
+        cli_1.default.log(color_1.default.cyan(`\n${this._resourceRepository._repositoryName} diff`));
+        const pairs = await (0, resource_differ_1.pairResources)(await this.getRemoteResources(), await this.getLocalResources(), (slug) => this._resourceRepository.existsMetadata(slug));
+        const notes = [];
+        const diffable = [];
+        let hiddenInherited = 0;
+        let sensitivityChanged = false;
+        for (const pair of pairs) {
+            // Same rule `status` applies: an inherited resource the cloud agrees on has nothing to show,
+            // but one that drifted is exactly what the user needs — a parent moving it is never swallowed.
+            if ((0, resource_differ_1.inheritedFrom)(pair) && (0, exports.isUnchangedStatus)(pair.status)) {
+                hiddenInherited++;
+                continue;
+            }
+            // A sensitive value is unknowable on both sides, so there is nothing to diff; a sensitivity
+            // change is a real difference the patch cannot show, so it is reported instead.
+            if (pair.status === types_1.ResourceStatus.SENSITIVITY_CHANGED) {
+                sensitivityChanged = true;
+                notes.push(color_1.default.yellow(`${pair.status} ${pair.slug} — sensitivity differs between local and cloud (values are never shown)`));
+                continue;
+            }
+            // An up-to-date resource is skipped rather than rendered and found equal: its two sides can
+            // still serialize differently (key order in parametersSchema.json, say) where the content
+            // hash — which is what "up to date" means — says they are the same.
+            if ((0, exports.isUnchangedStatus)(pair.status)) {
+                continue;
+            }
+            diffable.push(pair);
+        }
+        const sections = this.diffSections(diffable, pairs)
+            .map((section) => ({ ...section, files: section.files.filter((file) => (0, diff_1.hasDifference)(file)) }))
+            .filter((section) => section.files.length > 0);
+        for (const section of sections) {
+            cli_1.default.log('');
+            cli_1.default.log((0, colorize_resource_1.colorizeByStatus)(section.label, section.label));
+            for (const file of section.files) {
+                cli_1.default.log((0, diff_1.colorizeDiff)((0, diff_1.renderUnifiedDiff)(file)));
+            }
+        }
+        for (const note of notes) {
+            cli_1.default.log(note);
+        }
+        if (sections.length === 0 && !sensitivityChanged) {
+            cli_1.default.log(color_1.default.green(`✅ ${this._resourceRepository._repositoryName} up to date`));
+        }
+        // Counted rather than listed: a workspace built on a parent inherits dozens of resources, and a
+        // line each would bury the diff it was run for. Only the ones with nothing to show are in here.
+        if (hiddenInherited > 0) {
+            cli_1.default.log(color_1.default.cyan(`ℹ️  ${hiddenInherited} inherited ${this._resourceRepository._repositoryName} up to date (nothing to diff).`));
+        }
+        return sections.length > 0 || sensitivityChanged;
+    }
     async resourcesTableLog(resources) {
         cli_1.default.table(resources, {
             name: {

package/dist/core/commands/variables-command.d.ts

@@ -1,5 +1,12 @@
 import { Variable } from '../types';
 import ResourceCommand from './resource-command';
+import { DiffSection, ResourcePair } from '../../services/resource-differ';
 export default abstract class VariablesCommand extends ResourceCommand<Variable> {
     init(): Promise<void>;
+    /**
+     * Variables share their files, so they diff as one patch per file rather than one per key.
+     * Rendered from every variable, not just the changed ones, so hunks carry the surrounding keys
+     * and the line numbers of the real file.
+     */
+    protected diffSections(diffable: Array<ResourcePair<Variable>>, allPairs: Array<ResourcePair<Variable>>): Array<DiffSection>;
 }

package/dist/core/commands/variables-command.js

@@ -4,6 +4,7 @@ const variable_1 = require("../../repositories/variable");
 const resource_merger_1 = require("../resource-merger");
 const resource_pusher_1 = require("../resource-pusher");
 const resource_command_1 = require("./resource-command");
+const resource_differ_1 = require("../../services/resource-differ");
 class VariablesCommand extends resource_command_1.default {
     async init() {
         await super.init();
@@ -11,6 +12,18 @@ class VariablesCommand extends resource_command_1.default {
         this._resourceMerger = new resource_merger_1.default(this._resourceRepository);
         this._resourcePusher = new resource_pusher_1.default(this._resourceRepository, this._fcodeGraphQLClient);
         this._resourceQuery = () => this._fcodeGraphQLClient.allVariables.bind(this._fcodeGraphQLClient)();
+        this._diffFilesFor = (pair) => (0, resource_differ_1.variablesEnvDiffFiles)([pair]);
+    }
+    /**
+     * Variables share their files, so they diff as one patch per file rather than one per key.
+     * Rendered from every variable, not just the changed ones, so hunks carry the surrounding keys
+     * and the line numbers of the real file.
+     */
+    diffSections(diffable, allPairs) {
+        if (diffable.length === 0) {
+            return [];
+        }
+        return [{ label: resource_differ_1.VARIABLES_DIFF_PATH, files: (0, resource_differ_1.variablesEnvDiffFiles)(allPairs) }];
     }
 }
 exports.default = VariablesCommand;

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,44 @@ 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,
+        // shortening a locale nothing matches the same way they do.
         // 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;
+          // An identifier no locale matches is shortened one segment at a time ('en-gb' reads
+          // 'en'), by name first and ignoring case only as a last resort — the same chain the
+          // cloud resolves, so a local run answers a regional variant the same way.
+          const localeMaps = [];
+          for (let candidate = requested; candidate; ) {
+            const names = Object.keys(byLocale);
+            const lowered = candidate.toLowerCase();
+            const match = names.includes(candidate)
+              ? candidate
+              : names.filter((name) => name.toLowerCase() === lowered).sort()[0];
+            if (match !== undefined && !localeMaps.includes(byLocale[match])) {
+              localeMaps.push(byLocale[match]);
+            }
+            const lastSeparator = Math.max(candidate.lastIndexOf('-'), candidate.lastIndexOf('_'));
+            candidate = lastSeparator > 0 ? candidate.slice(0, lastSeparator) : undefined;
+          }
+          let template;
+          for (const localeMap of localeMaps) {
+            template = Object.hasOwn(localeMap, key) ? localeMap[key] : undefined;
+            if (template !== undefined) {
+              break;
+            }
+          }
+          if (template === undefined) {
+            template = Object.hasOwn(translations, key) ? translations[key] : undefined;
+          }
           if (template === undefined) {
             return key;
           }

package/dist/core/types.d.ts

@@ -101,6 +101,7 @@ export type MergedResource = MergedResourceRecord & {
     status: ResourceStatus;
 };
 export type ProgrammingLanguage = 'JAVASCRIPT' | 'PYTHON';
+export declare const PROGRAMMING_LANGUAGES: ReadonlyArray<ProgrammingLanguage>;
 export declare const programmingLanguageDisplayName: (programmingLanguage: ProgrammingLanguage) => string;
 export type WebhookAuthMode = 'NONE' | 'TEAM' | 'CUSTOM';
 export declare const DEFAULT_WEBHOOK_AUTH_HEADER = "Authorization";
@@ -130,12 +131,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 +165,7 @@ export declare class Process extends Resource {
     tags: string[];
     webhook?: ProcessWebhook;
     form?: ProcessForm;
+    uiTrigger?: ProcessUiTrigger;
     script: {
         parametersSchema: any;
         programmingLanguage: ProgrammingLanguage;
@@ -220,6 +240,20 @@ export declare class VersionedScriptLibrary extends Resource {
     constructor(id: string, tag: string, sourceCode: string, programmingLanguage: ProgrammingLanguage);
     get contentHash(): string;
 }
+/**
+ * A published snapshot of the dependencies a workspace declares for one language. Pulled read-only
+ * for visibility and git history: unlike process and module versions, these are never pushed back —
+ * `fcode settings:versions:create` is what publishes them.
+ */
+export declare class VersionedProgrammingLanguageManifest extends Resource {
+    id: string;
+    slug: string;
+    tag: string;
+    programmingLanguage: ProgrammingLanguage;
+    dependencies: Array<Dependency>;
+    constructor(tag: string, programmingLanguage: ProgrammingLanguage, dependencies: Array<Dependency>);
+    get contentHash(): string;
+}
 export declare class Variable extends Resource {
     static ENV_KEY_MAX_LENGTH: number;
     static ENV_KEY_REGEX: RegExp;
@@ -238,7 +272,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 {
@@ -246,8 +287,8 @@ export interface ErrorHandlerConfig {
     tag?: string | null;
 }
 export interface TeamVersionManifestEntry {
-    resourceType: 'MODULE' | 'PROCESS';
-    resourceId: string;
+    resourceType: 'DEPENDENCIES' | 'LOCALE' | 'MODULE' | 'PROCESS';
+    resourceId?: string | null;
     slug: string;
     outcome: 'CREATED' | 'FAILED' | 'SKIPPED_EXISTS' | 'SKIPPED_NO_TAG' | 'UPDATED';
     error?: string | null;
@@ -273,23 +314,28 @@ export interface TeamVersionAlias {
 export interface TeamVersionFileEntry {
     tag: string;
     comment?: string;
-    createdAt: string;
+    createdAt?: string;
 }
 export interface TeamAliasFileEntry {
     name: string;
     tag: string;
 }
-export declare class Team extends Resource {
+export interface ParentTeamRef {
+    slug: string;
+    version?: string;
+}
+/** The workspace's settings.json: what `fcode settings:pull|push` syncs against the cloud team. */
+export declare class WorkspaceSettings extends Resource {
     id: string | undefined;
     slug: string;
     zoneId?: string;
     errorHandlerConfig?: ErrorHandlerConfig;
-    parentTeamSlugs: string[];
+    parentTeams: ParentTeamRef[];
     webhookAuth?: WebhookAuth;
     primaryLocale?: string;
     versions?: TeamVersionFileEntry[];
     aliases?: TeamAliasFileEntry[];
-    constructor(slug: string, parentTeamSlugs: string[], zoneId?: string, errorHandlerConfig?: ErrorHandlerConfig, webhookAuth?: WebhookAuth, primaryLocale?: string);
+    constructor(slug: string, parentTeams: ParentTeamRef[], zoneId?: string, errorHandlerConfig?: ErrorHandlerConfig, webhookAuth?: WebhookAuth, primaryLocale?: string);
     get contentHash(): string;
 }
 export interface RawErrorHandlerConfig {
@@ -300,13 +346,13 @@ export interface RawTeamSettings {
     slug: string;
     zoneId?: string;
     errorHandlerConfig?: RawErrorHandlerConfig | null;
-    parentTeamSlugs: string[];
+    parentTeams: ParentTeamRef[];
     webhookAuth?: WebhookAuth | null;
     primaryLocale?: string | null;
 }
 export interface TeamUpdateInput {
     zoneId?: string;
-    parentTeamSlugs?: string[];
+    parentTeams?: ParentTeamRef[];
     executionErrorHandlerConfig?: RawErrorHandlerConfig | null;
     webhookAuth?: {
         headerName?: string | null;
@@ -352,6 +398,9 @@ export declare const ForceFlag: {
 export declare const ResourceSlugArg: {
     resourceSlug: import("@oclif/core/lib/interfaces").Arg<string | undefined, Record<string, unknown>>;
 };
+export declare const ShowInheritedFlag: {
+    showInherited: import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
+};
 export declare const TeamNameArg: {
     team: import("@oclif/core/lib/interfaces").Arg<string | undefined, Record<string, unknown>>;
 };
@@ -363,6 +412,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

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.ServiceAccount = exports.Dependency = exports.DependenciesFlags = exports.TeamNameArg = exports.ResourceSlugArg = exports.ForceFlag = exports.ScriptLibraryNotFound = exports.ProcessNotFound = exports.Team = exports.ProgrammingLanguageManifest = exports.Variable = exports.VersionedScriptLibrary = exports.Locale = exports.ScriptLibrary = exports.VersionedProcess = exports.Process = exports.DEFAULT_WEBHOOK_AUTH_HEADER = exports.programmingLanguageDisplayName = exports.ResourceStatus = exports.OnConflictResolution = exports.Resource = void 0;
+exports.ServiceAccount = exports.Dependency = exports.DependenciesFlags = exports.TeamNameArg = exports.ShowInheritedFlag = exports.ResourceSlugArg = exports.ForceFlag = exports.ScriptLibraryNotFound = exports.ProcessNotFound = exports.WorkspaceSettings = exports.ProgrammingLanguageManifest = exports.Variable = exports.VersionedProgrammingLanguageManifest = exports.VersionedScriptLibrary = exports.Locale = exports.ScriptLibrary = exports.VersionedProcess = exports.Process = exports.DEFAULT_WEBHOOK_AUTH_HEADER = exports.programmingLanguageDisplayName = exports.PROGRAMMING_LANGUAGES = exports.ResourceStatus = exports.OnConflictResolution = exports.Resource = void 0;
 const core_1 = require("@oclif/core");
 const crypto = require("node:crypto");
 const canonical_hash_1 = require("../utils/canonical-hash");
@@ -28,6 +28,7 @@ var ResourceStatus;
     ResourceStatus["SENSITIVE"] = "\uD83D\uDD12 (sensitive)";
     ResourceStatus["SENSITIVITY_CHANGED"] = "\uD83D\uDEAB (sensitivity-changed)";
 })(ResourceStatus || (exports.ResourceStatus = ResourceStatus = {}));
+exports.PROGRAMMING_LANGUAGES = ['JAVASCRIPT', 'PYTHON'];
 const programmingLanguageDisplayName = (programmingLanguage) => {
     switch (programmingLanguage) {
         case 'JAVASCRIPT':
@@ -49,6 +50,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 +67,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 WorkspaceSettings.contentHash).
+            ...(this.uiTrigger && { uiTrigger: this.uiTrigger }),
             manifestDependencies: this.manifest.dependencies,
             dependenciesScopedToProcess: this.settings.dependencies.scopedToProcess,
         });
@@ -152,6 +157,25 @@ class VersionedScriptLibrary extends Resource {
     }
 }
 exports.VersionedScriptLibrary = VersionedScriptLibrary;
+/**
+ * A published snapshot of the dependencies a workspace declares for one language. Pulled read-only
+ * for visibility and git history: unlike process and module versions, these are never pushed back —
+ * `fcode settings:versions:create` is what publishes them.
+ */
+class VersionedProgrammingLanguageManifest extends Resource {
+    constructor(tag, programmingLanguage, dependencies) {
+        super();
+        this.id = `${tag}#${programmingLanguage}`;
+        this.slug = programmingLanguage;
+        this.tag = tag;
+        this.programmingLanguage = programmingLanguage;
+        this.dependencies = dependencies;
+    }
+    get contentHash() {
+        return crypto.createHash('md5').update(JSON.stringify(this.dependencies)).digest('hex');
+    }
+}
+exports.VersionedProgrammingLanguageManifest = VersionedProgrammingLanguageManifest;
 class Variable extends Resource {
     constructor(id, key, value, isSensitive, resolvingTeamSlug) {
         super();
@@ -185,12 +209,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
@@ -200,11 +234,12 @@ class ProgrammingLanguageManifest extends Resource {
     }
 }
 exports.ProgrammingLanguageManifest = ProgrammingLanguageManifest;
-class Team extends Resource {
-    constructor(slug, parentTeamSlugs, zoneId, errorHandlerConfig, webhookAuth, primaryLocale) {
+/** The workspace's settings.json: what `fcode settings:pull|push` syncs against the cloud team. */
+class WorkspaceSettings extends Resource {
+    constructor(slug, parentTeams, zoneId, errorHandlerConfig, webhookAuth, primaryLocale) {
         super();
         this.slug = slug;
-        this.parentTeamSlugs = parentTeamSlugs;
+        this.parentTeams = parentTeams;
         this.zoneId = zoneId;
         this.errorHandlerConfig = errorHandlerConfig;
         this.webhookAuth = webhookAuth;
@@ -215,24 +250,38 @@ class Team extends Resource {
             zoneId: this.zoneId || null,
             errorHandlerConfig: this.errorHandlerConfig || null,
             // Kept in the given order, not sorted: the order is the inheritance precedence, so a pure
-            // reorder is a real change that must be detected and pushed.
-            parentTeamSlugs: [...(this.parentTeamSlugs || [])],
+            // reorder is a real change that must be detected and pushed. Renamed from parentTeamSlugs
+            // when version pins arrived, so every workspace with parents reports settings.json modified
+            // once after upgrading — a deliberate one-time diff.
+            parentTeams: (this.parentTeams || []).map(({ slug, version }) => version ? { slug, version } : { slug }),
         };
-        // Inserted only when set, so every team.json that predates webhook auth keeps the
+        // Inserted only when set, so every settings.json that predates webhook auth keeps the
         // hash already stored in .fcode and does not report a phantom conflict. A key present
         // with an undefined value would not do: canonicalStringify writes that as null.
         if (this.webhookAuth) {
             payload.webhookAuth = this.webhookAuth;
         }
-        // Same insert-only-when-set rule, for the same reason: a team.json written before locales
+        // Same insert-only-when-set rule, for the same reason: a settings.json written before locales
         // existed must keep the hash already stored in .fcode.
         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);
     }
 }
-exports.Team = Team;
+exports.WorkspaceSettings = WorkspaceSettings;
 class ProcessNotFound extends Error {
 }
 exports.ProcessNotFound = ProcessNotFound;
@@ -251,6 +300,11 @@ exports.ResourceSlugArg = {
         name: 'slug',
     }),
 };
+exports.ShowInheritedFlag = {
+    showInherited: core_1.Flags.boolean({
+        description: 'Also list inherited resources that have no changes',
+    }),
+};
 exports.TeamNameArg = {
     team: core_1.Args.string({ description: 'Team name', name: 'team' }),
 };