@factorialco/fcode-cli 2.4.0 → 3.0.0

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/executors/javascript-execution-task.js

@@ -596,7 +596,8 @@ const main = typeof _hooksModule['${fn}'] === 'function'
         // 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.
+        // 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) => {
           const translations = ${JSON.stringify(metadata.i18n.translations, null, 2)};
@@ -604,8 +605,29 @@ const main = typeof _hooksModule['${fn}'] === 'function'
           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;
+          // 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;
           }

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";
@@ -239,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;
@@ -272,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;
@@ -305,17 +320,22 @@ 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 {
@@ -326,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;
@@ -378,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>>;
 };

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':
@@ -67,7 +68,7 @@ class Process extends Resource {
             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).
+            // content hash already stored in .fcode (mirrors WorkspaceSettings.contentHash).
             ...(this.uiTrigger && { uiTrigger: this.uiTrigger }),
             manifestDependencies: this.manifest.dependencies,
             dependenciesScopedToProcess: this.settings.dependencies.scopedToProcess,
@@ -156,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();
@@ -214,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;
@@ -229,16 +250,18 @@ 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;
@@ -258,7 +281,7 @@ class Team extends Resource {
         return (0, canonical_hash_1.canonicalJsonHash)(payload);
     }
 }
-exports.Team = Team;
+exports.WorkspaceSettings = WorkspaceSettings;
 class ProcessNotFound extends Error {
 }
 exports.ProcessNotFound = ProcessNotFound;
@@ -277,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' }),
 };

package/dist/repositories/process.d.ts

@@ -1,5 +1,12 @@
-import { Process, ResourceMetadata, VersionedProcess } from '../core/types';
+import { Process, ProcessMetadataFields, ProgrammingLanguage, ResourceMetadata, VersionedProcess } from '../core/types';
 import ResourceRepositoryBase from './resource';
+/**
+ * What a process writes to metadata.json. Exported so anything rendering a process as its files
+ * — `saveFiles` here, `fcode diff` — produces the same bytes for the same process.
+ */
+export declare function buildProcessMetadata(process: Process): ProcessMetadataFields;
+export declare const PROCESS_SOURCE_CODE_FILE_NAME: (programmingLanguage: string) => string;
+export declare const PROCESS_DEPENDENCIES_FILE_NAME: (programmingLanguage: ProgrammingLanguage) => string;
 declare class ProcessRepository extends ResourceRepositoryBase<Process> {
     constructor();
     protected buildResourcePath(process: Process, filename: string, version?: string): string;
@@ -12,7 +19,6 @@ declare class ProcessRepository extends ResourceRepositoryBase<Process> {
     findSlugsNotAdded(): Promise<Array<string>>;
     find(processSlug: string, version?: string): Promise<Process>;
     private readMetadataFile;
-    private buildMetadata;
     findParameters(processSlug: string): Promise<any>;
     getLastFileModifiedDate(process: Process, filename: string): Promise<Date>;
     protected getResourcePath(process: Process): string;

package/dist/repositories/process.js

@@ -1,5 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.PROCESS_DEPENDENCIES_FILE_NAME = exports.PROCESS_SOURCE_CODE_FILE_NAME = void 0;
+exports.buildProcessMetadata = buildProcessMetadata;
 const fs = require("fs-extra");
 const crypto = require("node:crypto");
 const path = require("node:path");
@@ -17,6 +19,30 @@ const PROGRAMMING_LANGUAGE_DEPENDENCIES_FILE_NAME = {
     JAVASCRIPT: 'package.json',
     PYTHON: 'requirements.txt',
 };
+/**
+ * What a process writes to metadata.json. Exported so anything rendering a process as its files
+ * — `saveFiles` here, `fcode diff` — produces the same bytes for the same process.
+ */
+function buildProcessMetadata(process) {
+    const metadata = { name: process.name, tags: process.tags ?? [] };
+    if (process.description !== undefined) {
+        metadata.description = process.description;
+    }
+    if (process.webhook !== undefined) {
+        metadata.webhook = process.webhook;
+    }
+    if (process.form !== undefined) {
+        metadata.form = process.form;
+    }
+    if (process.uiTrigger !== undefined) {
+        metadata.uiTrigger = process.uiTrigger;
+    }
+    return metadata;
+}
+const PROCESS_SOURCE_CODE_FILE_NAME = (programmingLanguage) => (programmingLanguage === 'PYTHON' ? 'main.py' : 'index.js');
+exports.PROCESS_SOURCE_CODE_FILE_NAME = PROCESS_SOURCE_CODE_FILE_NAME;
+const PROCESS_DEPENDENCIES_FILE_NAME = (programmingLanguage) => PROGRAMMING_LANGUAGE_DEPENDENCIES_FILE_NAME[programmingLanguage];
+exports.PROCESS_DEPENDENCIES_FILE_NAME = PROCESS_DEPENDENCIES_FILE_NAME;
 class ProcessRepository extends resource_1.default {
     constructor() {
         super({
@@ -34,7 +60,7 @@ class ProcessRepository extends resource_1.default {
         return (0, filenamify_1.default)(process.slug);
     }
     getSourceCodeFileName(programmingLanguage) {
-        return programmingLanguage === 'PYTHON' ? 'main.py' : 'index.js';
+        return (0, exports.PROCESS_SOURCE_CODE_FILE_NAME)(programmingLanguage);
     }
     async findAll() {
         const { processes } = await this.workspaceConfig.getActiveTeam();
@@ -146,22 +172,6 @@ class ProcessRepository extends resource_1.default {
             return { name: processSlug, tags: [] };
         }
     }
-    buildMetadata(process) {
-        const metadata = { name: process.name, tags: process.tags ?? [] };
-        if (process.description !== undefined) {
-            metadata.description = process.description;
-        }
-        if (process.webhook !== undefined) {
-            metadata.webhook = process.webhook;
-        }
-        if (process.form !== undefined) {
-            metadata.form = process.form;
-        }
-        if (process.uiTrigger !== undefined) {
-            metadata.uiTrigger = process.uiTrigger;
-        }
-        return metadata;
-    }
     async findParameters(processSlug) {
         const processMetadata = await this.getProcessMetadata(processSlug);
         if (!processMetadata) {
@@ -238,7 +248,7 @@ class ProcessRepository extends resource_1.default {
             readOnly,
         });
         (0, file_utils_1.outputFileSyncIfChanged)(this.buildResourcePath(process, 'README.md'), process.readme || '', { readOnly });
-        (0, file_utils_1.outputFileSyncIfChanged)(this.buildResourcePath(process, 'metadata.json'), JSON.stringify(this.buildMetadata(process), null, 2), { readOnly });
+        (0, file_utils_1.outputFileSyncIfChanged)(this.buildResourcePath(process, 'metadata.json'), JSON.stringify(buildProcessMetadata(process), null, 2), { readOnly });
         (0, file_utils_1.outputFileSyncIfChanged)(this.buildResourcePath(process, 'parametersSchema.json'), JSON.stringify(process.script.parametersSchema, null, 2), { readOnly });
         const parametersFilePath = this.buildResourcePath(process, 'parameters.json');
         if (!fs.existsSync(parametersFilePath)) {

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

@@ -1,4 +1,4 @@
-import { ProgrammingLanguage, ProgrammingLanguageManifest, ResourceMetadata } from '../core/types';
+import { ProgrammingLanguage, ProgrammingLanguageManifest, ResourceMetadata, VersionedProgrammingLanguageManifest } from '../core/types';
 import ResourceRepositoryBase from './resource';
 /**
  * The inherited file each language collapses its parents into. Exported so the gitignore sync names
@@ -10,6 +10,7 @@ declare class ProgrammingLanguageManifestRepository extends ResourceRepositoryBa
     constructor();
     find(slug: string): Promise<ProgrammingLanguageManifest>;
     protected getSourceCodeFileName(programmingLanguageManifest: ProgrammingLanguageManifest): string;
+    private getSourceCodeFileNameFor;
     /**
      * 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
@@ -28,6 +29,19 @@ declare class ProgrammingLanguageManifestRepository extends ResourceRepositoryBa
     metadataFromFiles(slug: string): Promise<ResourceMetadata>;
     validSlug(slug: string): boolean;
     slugFormatMessage(): string;
+    /**
+     * Published snapshots live under `dependencies/versions/<tag>/`, one manifest file per language,
+     * mirroring the `versions/` folders of processes and modules. Written read-only: unlike those,
+     * these are pulled for visibility only — `fcode settings:versions:create` is what publishes them, and
+     * editing one here would push nothing.
+     */
+    private versionsDirectory;
+    private versionDirectory;
+    private versionPath;
+    getLocalVersionTags(): string[];
+    versionExistsLocally(version: VersionedProgrammingLanguageManifest): boolean;
+    removeVersion(tag: string): void;
+    saveVersion(version: VersionedProgrammingLanguageManifest): Promise<void>;
     findSlugsNotAdded(): Promise<Array<string>>;
 }
 export default ProgrammingLanguageManifestRepository;