@factorialco/fcode-cli 2.0.0 → 2.1.0

package/dist/repositories/team.js

@@ -29,7 +29,15 @@ class TeamRepository {
         }
         catch { }
         const parentTeamSlugs = Array.isArray(raw.parentTeamSlugs) ? raw.parentTeamSlugs : [];
-        return new types_1.Team(slug, parentTeamSlugs, raw.zoneId, this.parseErrorHandler(raw.errorHandlerConfig), this.parseWebhookAuth(raw.webhookAuth));
+        const team = new types_1.Team(slug, parentTeamSlugs, raw.zoneId, this.parseErrorHandler(raw.errorHandlerConfig), this.parseWebhookAuth(raw.webhookAuth));
+        // Parsed so a find()+save() round-trip does not drop the pull-only fields.
+        if (Array.isArray(raw.versions)) {
+            team.versions = raw.versions;
+        }
+        if (Array.isArray(raw.aliases)) {
+            team.aliases = raw.aliases;
+        }
+        return team;
     }
     save(team) {
         (0, file_utils_1.outputFileSyncIfChanged)(TEAM_FILENAME, JSON.stringify(this.toFile(team), null, 2));
@@ -45,6 +53,25 @@ class TeamRepository {
         }
         return new types_1.Team(raw.slug, raw.parentTeamSlugs ?? [], raw.zoneId, errorHandlerConfig, this.parseWebhookAuth(raw.webhookAuth));
     }
+    /**
+     * Writes the cloud's team versions and aliases into the Team as the pull-only team.json
+     * fields (sorted for stable git diffs). These fields never enter the content hash and are
+     * stripped from pushes: all writes go through the team:versions/team:aliases commands.
+     */
+    applyCloudVersioning(team, versions, aliases) {
+        team.versions = versions
+            .map((version) => {
+            const entry = { tag: version.tag, createdAt: version.createdAt };
+            if (version.comment) {
+                entry.comment = version.comment;
+            }
+            return entry;
+        })
+            .sort((a, b) => a.createdAt.localeCompare(b.createdAt));
+        team.aliases = aliases
+            .map((alias) => ({ name: alias.name, tag: alias.tag }))
+            .sort((a, b) => a.name.localeCompare(b.name));
+    }
     async resolveSlugToId(processSlug) {
         const { processes } = await this.workspaceConfig.getActiveTeam();
         return processes[processSlug]?.id ?? processSlug;
@@ -84,6 +111,13 @@ class TeamRepository {
         if (team.webhookAuth !== undefined) {
             file.webhookAuth = team.webhookAuth;
         }
+        // Pull-only global versioning fields, appended after the pushable settings.
+        if (team.versions !== undefined) {
+            file.versions = team.versions;
+        }
+        if (team.aliases !== undefined) {
+            file.aliases = team.aliases;
+        }
         return file;
     }
 }

package/dist/repositories/variable.d.ts

@@ -4,16 +4,40 @@ export declare const DEFAULT_SENSITIVE_VALUE = "********";
 declare class VariableRepository extends ResourceRepositoryBase<Variable> {
     private filename;
     private localFilename;
+    private inheritedFilename;
     private filenameInitPromise;
     constructor();
     private ensureFilenamesInitialized;
     findAll(): Promise<Variable[]>;
+    /**
+     * Values as a local run sees them. Precedence, lowest first: variables inherited from
+     * parent workspaces, this workspace's own variables, and the local overrides file — the
+     * same order the platform applies, where a workspace's own value wins over an inherited one.
+     * An empty value is not an override but an unset one: the platform rejects blank values, and
+     * a variable emptied in variables.env is a removal (see `mapResourceStatus`), so an empty
+     * entry falls through to the layer below rather than blanking it.
+     */
     findAllForExecution(): Promise<Variable[]>;
+    /**
+     * An inherited key the workspace has given a value of its own, overriding it. An empty entry
+     * does not count: the platform has no empty values, so it reads as "not set" here too.
+     */
+    private overridesInherited;
     find(slug: string): Promise<Variable>;
+    /**
+     * Keys declared in the workspace's own variables file that its metadata does not claim yet.
+     * A key the workspace inherits counts as one of those: the metadata still points at the
+     * parent's variable, and adding it is what turns the entry into this workspace's own.
+     */
     findSlugsNotAdded(): Promise<Array<string>>;
     protected getResourcePath(_resource: Variable): string;
     protected removeFiles(variable: Variable): Promise<void>;
     protected resourceToMetadata(variable: Variable): ResourceMetadata;
+    /**
+     * A variable owned by this workspace goes to the committed variables file; one inherited
+     * from a parent workspace goes to the gitignored inherited file, so a local run can use it
+     * without the child workspace's git history carrying a copy of its parent's values.
+     */
     protected saveFiles(variable: Variable): Promise<void>;
     metadataFromFiles(slug: string, opts: AddResourceOptions): Promise<ResourceMetadata>;
     private readVariablesMeta;

package/dist/repositories/variable.js

@@ -20,6 +20,7 @@ class VariableRepository extends resource_1.default {
         });
         this.filename = null;
         this.localFilename = null;
+        this.inheritedFilename = null;
         this.filenameInitPromise = null;
     }
     async ensureFilenamesInitialized() {
@@ -30,40 +31,67 @@ class VariableRepository extends resource_1.default {
             const globalConfig = new global_1.default();
             this.filename = await globalConfig.getSetting(settings_1.SettingKeys.VARIABLES_FILE_NAME);
             this.localFilename = await globalConfig.getSetting(settings_1.SettingKeys.LOCAL_VARIABLES_FILE_NAME);
+            this.inheritedFilename = await globalConfig.getSetting(settings_1.SettingKeys.INHERITED_VARIABLES_FILE_NAME);
         })();
         return this.filenameInitPromise;
     }
     async findAll() {
         await this.ensureFilenamesInitialized();
-        const rawVariables = this.readVariablesFromFile();
-        const localOverrideKeys = new Set(Object.keys(this.readVariablesFromFile(true)));
+        const rawVariables = this.readVariablesFromFile('own');
+        const inheritedRawVariables = this.readVariablesFromFile('inherited');
+        const localOverrideKeys = new Set(Object.keys(this.readVariablesFromFile('local')));
         const meta = this.readVariablesMeta();
         const variables = [];
         const { variables: localVariables } = await this.workspaceConfig.getActiveTeam();
         for (const localVariableKey of Object.keys(localVariables)) {
             const localVariable = localVariables[localVariableKey];
             const isSensitive = meta[localVariable.key]?.isSensitive ?? false;
-            const variable = types_1.Variable.validate(new types_1.Variable(localVariable.id, localVariable.key, rawVariables[localVariable.key], isSensitive));
+            // Writing an inherited key into variables.env is how you override it, so from that
+            // moment the variable is this workspace's: it drops the parent's id and inherited
+            // marker, which is what makes `push` create it here instead of skipping it.
+            const overridesInherited = this.overridesInherited(localVariable, rawVariables);
+            const resolvingTeamSlug = overridesInherited ? undefined : localVariable.resolvingTeamSlug;
+            const id = overridesInherited ? undefined : localVariable.id;
+            const rawValue = resolvingTeamSlug ? inheritedRawVariables[localVariable.key] : rawVariables[localVariable.key];
+            const variable = types_1.Variable.validate(new types_1.Variable(id, localVariable.key, rawValue, isSensitive, resolvingTeamSlug));
             variable.overriddenLocally = localOverrideKeys.has(localVariable.key);
             variables.push(variable);
         }
         return variables;
     }
+    /**
+     * Values as a local run sees them. Precedence, lowest first: variables inherited from
+     * parent workspaces, this workspace's own variables, and the local overrides file — the
+     * same order the platform applies, where a workspace's own value wins over an inherited one.
+     * An empty value is not an override but an unset one: the platform rejects blank values, and
+     * a variable emptied in variables.env is a removal (see `mapResourceStatus`), so an empty
+     * entry falls through to the layer below rather than blanking it.
+     */
     async findAllForExecution() {
         await this.ensureFilenamesInitialized();
-        const rawVariables = this.readVariablesFromFile();
-        const localRawVariables = this.readVariablesFromFile(true);
+        const rawVariables = this.readVariablesFromFile('own');
+        const inheritedRawVariables = this.readVariablesFromFile('inherited');
+        const localRawVariables = this.readVariablesFromFile('local');
         const meta = this.readVariablesMeta();
         const variables = [];
         const { variables: localVariables } = await this.workspaceConfig.getActiveTeam();
         for (const localVariableKey of Object.keys(localVariables)) {
             const localVariable = localVariables[localVariableKey];
-            const value = localRawVariables[localVariable.key] || rawVariables[localVariable.key];
-            const isSensitive = meta[localVariable.key]?.isSensitive ?? false;
-            variables.push(types_1.Variable.validate(new types_1.Variable(localVariable.id, localVariable.key, value, isSensitive)));
+            const key = localVariable.key;
+            const isSensitive = meta[key]?.isSensitive ?? false;
+            const value = localRawVariables[key] || rawVariables[key] || inheritedRawVariables[key];
+            const resolvingTeamSlug = this.overridesInherited(localVariable, rawVariables) ? undefined : localVariable.resolvingTeamSlug;
+            variables.push(types_1.Variable.validate(new types_1.Variable(localVariable.id, key, value, isSensitive, resolvingTeamSlug)));
         }
         return variables;
     }
+    /**
+     * An inherited key the workspace has given a value of its own, overriding it. An empty entry
+     * does not count: the platform has no empty values, so it reads as "not set" here too.
+     */
+    overridesInherited(metadata, ownRawVariables) {
+        return Boolean(metadata.resolvingTeamSlug) && Boolean(ownRawVariables[metadata.key]);
+    }
     async find(slug) {
         let variables = await this.findAll();
         variables = variables.filter((v) => v.key === slug);
@@ -72,12 +100,19 @@ class VariableRepository extends resource_1.default {
         }
         throw new errors_1.LocalVariableNotFound(new Error('Variable not found on team metadata'), slug);
     }
+    /**
+     * Keys declared in the workspace's own variables file that its metadata does not claim yet.
+     * A key the workspace inherits counts as one of those: the metadata still points at the
+     * parent's variable, and adding it is what turns the entry into this workspace's own.
+     */
     async findSlugsNotAdded() {
         await this.ensureFilenamesInitialized();
+        const ownRawVariables = this.readVariablesFromFile('own');
         const { variables: localVariables } = await this.workspaceConfig.getActiveTeam();
         const slugsNotAdded = [];
-        for (const [key, _value] of Object.entries(this.readVariablesFromFile())) {
-            if (!localVariables[key]) {
+        for (const key of Object.keys(ownRawVariables)) {
+            const metadata = localVariables[key];
+            if (!metadata || this.overridesInherited(metadata, ownRawVariables)) {
                 slugsNotAdded.push(key);
             }
         }
@@ -88,9 +123,10 @@ class VariableRepository extends resource_1.default {
     }
     async removeFiles(variable) {
         await this.ensureFilenamesInitialized();
-        let rawVariables = this.readVariablesFromFile();
+        const file = variable.resolvingTeamSlug ? 'inherited' : 'own';
+        const rawVariables = this.readVariablesFromFile(file);
         delete rawVariables[variable.key];
-        this.writeRawVariables(rawVariables);
+        this.writeRawVariables(rawVariables, file);
         const meta = this.readVariablesMeta();
         delete meta[variable.key];
         this.writeVariablesMeta(meta);
@@ -100,13 +136,20 @@ class VariableRepository extends resource_1.default {
             id: variable.id,
             slug: variable.slug,
             key: variable.key,
+            ...(variable.resolvingTeamSlug && { resolvingTeamSlug: variable.resolvingTeamSlug }),
         };
     }
+    /**
+     * A variable owned by this workspace goes to the committed variables file; one inherited
+     * from a parent workspace goes to the gitignored inherited file, so a local run can use it
+     * without the child workspace's git history carrying a copy of its parent's values.
+     */
     async saveFiles(variable) {
         await this.ensureFilenamesInitialized();
-        let rawVariables = this.readVariablesFromFile();
-        rawVariables = Object.assign(rawVariables, { [variable.key]: this.valueToSave(variable) });
-        this.writeRawVariables(rawVariables);
+        const file = variable.resolvingTeamSlug ? 'inherited' : 'own';
+        const rawVariables = this.readVariablesFromFile(file);
+        rawVariables[variable.key] = this.valueToSave(variable);
+        this.writeRawVariables(rawVariables, file);
         const meta = this.readVariablesMeta();
         meta[variable.key] = { isSensitive: variable.isSensitive };
         this.writeVariablesMeta(meta);
@@ -139,15 +182,20 @@ class VariableRepository extends resource_1.default {
         }, {});
         (0, file_utils_1.outputFileSyncIfChanged)(VARIABLES_META_FILENAME, JSON.stringify(sorted, null, 2));
     }
-    filePath(useLocalVersion = false) {
-        if (!this.filename || !this.localFilename) {
+    filePath(file = 'own') {
+        if (!this.filename || !this.localFilename || !this.inheritedFilename) {
             throw new Error('Filenames not initialized. Call ensureFilenamesInitialized() first.');
         }
-        return path.join(useLocalVersion ? this.localFilename : this.filename);
+        const filenames = {
+            own: this.filename,
+            local: this.localFilename,
+            inherited: this.inheritedFilename,
+        };
+        return path.join(filenames[file]);
     }
-    readVariablesFromFile(useLocalVersion = false) {
+    readVariablesFromFile(file = 'own') {
         try {
-            const result = (0, dotenv_1.parse)(fs.readFileSync(this.filePath(useLocalVersion), 'utf8')) || {};
+            const result = (0, dotenv_1.parse)(fs.readFileSync(this.filePath(file), 'utf8')) || {};
             for (const [key, value] of Object.entries(result)) {
                 result[key] = (0, env_utils_1.unescapeEnvValue)(value);
             }
@@ -163,12 +211,12 @@ class VariableRepository extends resource_1.default {
         }
         return variable.value;
     }
-    writeRawVariables(rawVariables) {
+    writeRawVariables(rawVariables, file = 'own') {
         const envContent = Object.entries(rawVariables)
             .sort((a, b) => a[0].localeCompare(b[0]))
             .map(([key, value]) => `${key}=${(0, env_utils_1.escapeEnvValue)(value)}`)
             .join('\n');
-        (0, file_utils_1.outputFileSyncIfChanged)(this.filePath(), envContent);
+        (0, file_utils_1.outputFileSyncIfChanged)(this.filePath(file), envContent);
     }
 }
 exports.default = VariableRepository;

package/dist/runtime/executor.js

@@ -3,7 +3,7 @@ const path = require('node:path')
 const { execSync } = require('node:child_process')
 const os = require('node:os')
 
-const YC_COMMAND = process.env.YC_COMMAND ?? "fcode"
+const FC_COMMAND = process.env.FC_COMMAND ?? "fcode"
 
 const file = process.argv[2]
 if (!fs.existsSync(file)) {
@@ -36,7 +36,7 @@ let dependenciesPath = ''
 try {
   version = getVersion(relativePath)
   const tempDir = fs.mkdtempSync(path.join(os.tmpdir(), 'fcode-'))
-  const command = [YC_COMMAND, 'pre-debug', absolutePath, '-t', tempDir]
+  const command = [FC_COMMAND, 'pre-debug', absolutePath, '-t', tempDir]
   if (version) {
     command.push('-v')
     command.push(version)

package/dist/runtime/executor.py

@@ -4,7 +4,7 @@ import subprocess
 import tempfile
 
 
-YC_COMMAND = os.environ.get("YC_COMMAND", "fcode")
+FC_COMMAND = os.environ.get("FC_COMMAND", "fcode")
 file = sys.argv[1]
 if not os.path.exists(file):
     print("File not found: " + file)
@@ -31,7 +31,7 @@ main_file_path = ""
 try:
     version = get_version(file)
     tempDir = tempfile.TemporaryDirectory()
-    command = [YC_COMMAND, "pre-debug", file, "-t", tempDir.name]
+    command = [FC_COMMAND, "pre-debug", file, "-t", tempDir.name]
     if version != None:
         command.append("-v")
         command.append(version)

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

@@ -3,7 +3,7 @@ import json
 import subprocess
 import logging
 
-YC_COMMAND = os.environ.get("YC_COMMAND", "fcode")
+FC_COMMAND = os.environ.get("FC_COMMAND", "fcode")
 
 metadata = {
     "execution": {"process": {"name": "", "id": ""}},
@@ -24,7 +24,7 @@ else:
     os.environ.get("FCODE_LOG_LEVEL", "") == "DEBUG" and print(
         "[FCODE LIBRARY] Reading metadata from process-metadata command"
     )
-    command = [YC_COMMAND, "process-metadata"]
+    command = [FC_COMMAND, "process-metadata"]
     if process_slug:
         command.append(process_slug)
         if process_slug and process_version:

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

@@ -1,5 +1,5 @@
 import { GraphQLClient } from 'graphql-request';
-import { Process, ProgrammingLanguage, ProgrammingLanguageManifest, RawTeamSettings, ScriptLibrary, TeamUpdateInput, Variable, VersionedProcess, VersionedScriptLibrary, ServiceAccount } from '../core/types';
+import { Process, ProgrammingLanguage, ProgrammingLanguageManifest, RawTeamSettings, ScriptLibrary, TeamUpdateInput, TeamVersion, TeamVersionAlias, Variable, VersionedProcess, VersionedScriptLibrary, ServiceAccount } from '../core/types';
 export type FcodeGraphQLClientOptions = {
     url: string;
     accessToken: string;
@@ -44,6 +44,15 @@ declare class FcodeGraphQLClient {
      * undefined.
      */
     mapTeamSettings(team: any): RawTeamSettings;
+    mapTeamVersion(teamVersion: any): TeamVersion;
+    mapTeamVersionAlias(alias: any): TeamVersionAlias;
+    allTeamVersions(): Promise<Array<TeamVersion>>;
+    createTeamVersion(tag: string, comment?: string): Promise<TeamVersion>;
+    deleteTeamVersion(tag: string): Promise<TeamVersion>;
+    allTeamVersionAliases(): Promise<Array<TeamVersionAlias>>;
+    /** The API upserts: an existing alias with the same name is re-pointed to the tag. */
+    createTeamVersionAlias(name: string, tag: string): Promise<TeamVersionAlias>;
+    deleteTeamVersionAlias(id: string): Promise<TeamVersionAlias>;
     team(): Promise<RawTeamSettings>;
     pushTeam(update: TeamUpdateInput): Promise<RawTeamSettings>;
     mapProgrammingLanguageManifest(programmingLanguageManifest: any): ProgrammingLanguageManifest;

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

@@ -3,6 +3,31 @@ Object.defineProperty(exports, "__esModule", { value: true });
 const graphql_request_1 = require("graphql-request");
 const types_1 = require("../core/types");
 const _ = require("lodash");
+// Shared team version selections so every query/mutation returns the same shape.
+const TEAM_VERSION_FIELDS = `
+  id
+  tag
+  comment
+  createdAt
+  createdBy {
+    id
+    name
+  }
+  manifest {
+    resourceType
+    resourceId
+    slug
+    outcome
+    error
+  }
+`;
+const TEAM_VERSION_ALIAS_FIELDS = `
+  id
+  name
+  tag
+  createdAt
+  updatedAt
+`;
 // Shared process selection so pull queries and push mutations return the same
 // fields, keeping mapProcess (and therefore contentHash) consistent.
 const PROCESS_FIELDS = `
@@ -236,33 +261,46 @@ class FcodeGraphQLClient {
             return Promise.reject(this.cleanError(error));
         });
     }
-    allVariables() {
-        return this.client
-            .request((0, graphql_request_1.gql) `
-          query teamVariables($first: Int!, $after: String) {
-            teamVariables(first: $first, after: $after) {
-              edges {
-                node {
-                  id
-                  key
-                  value
-                  isSensitive
+    // Pages through every variable: a workspace lists its own plus the ones inherited from
+    // its parent workspaces, so a single page is not enough to be sure nothing is missed.
+    async allVariables() {
+        const pageSize = 200;
+        const variables = [];
+        let after = null;
+        try {
+            do {
+                const { teamVariables: { edges, pageInfo }, } = await this.client.request((0, graphql_request_1.gql) `
+            query teamVariables($first: Int!, $after: String) {
+              teamVariables(first: $first, after: $after) {
+                edges {
+                  node {
+                    id
+                    key
+                    value
+                    isSensitive
+                    resolvingTeamSlug
+                  }
+                }
+                pageInfo {
+                  hasNextPage
+                  endCursor
                 }
-              }
-              pageInfo {
-                hasNextPage
-                endCursor
               }
             }
-          }
-        `, {
-            after: null,
-            first: 200,
-        })
-            .then(({ teamVariables: { edges } }) => edges.map(({ node: { id, isSensitive, key, value } }) => new types_1.Variable(id, key, value, isSensitive)))
-            .catch((error) => {
+          `, {
+                    after,
+                    first: pageSize,
+                });
+                for (const { node: { id, isSensitive, key, value, resolvingTeamSlug }, } of edges) {
+                    variables.push(new types_1.Variable(id, key, value, isSensitive, this.inheritedTeam(resolvingTeamSlug)));
+                }
+                after = pageInfo?.hasNextPage ? pageInfo.endCursor : null;
+            } while (after);
+        }
+        catch (error) {
             return Promise.reject(this.cleanError(error));
-        });
+        }
+        return variables;
     }
     toProcessInput(process, includeCreateOnly) {
         const settings = {
@@ -603,6 +641,116 @@ class FcodeGraphQLClient {
         }
         return settings;
     }
+    mapTeamVersion(teamVersion) {
+        return {
+            id: teamVersion.id,
+            tag: teamVersion.tag,
+            comment: teamVersion.comment ?? null,
+            manifest: (teamVersion.manifest ?? []).map((entry) => ({
+                resourceType: entry.resourceType,
+                resourceId: entry.resourceId,
+                slug: entry.slug,
+                outcome: entry.outcome,
+                error: entry.error ?? null,
+            })),
+            createdAt: teamVersion.createdAt,
+            createdBy: teamVersion.createdBy ?? null,
+        };
+    }
+    mapTeamVersionAlias(alias) {
+        return {
+            id: alias.id,
+            name: alias.name,
+            tag: alias.tag,
+            createdAt: alias.createdAt,
+            updatedAt: alias.updatedAt ?? null,
+        };
+    }
+    allTeamVersions() {
+        return this.client
+            .request((0, graphql_request_1.gql) `
+          query allTeamVersions {
+            allTeamVersions {
+              ${TEAM_VERSION_FIELDS}
+            }
+          }
+        `)
+            .then(({ allTeamVersions }) => allTeamVersions.map((teamVersion) => this.mapTeamVersion(teamVersion)))
+            .catch((error) => {
+            return Promise.reject(this.cleanError(error));
+        });
+    }
+    createTeamVersion(tag, comment) {
+        return this.client
+            .request((0, graphql_request_1.gql) `
+          mutation createTeamVersion($tag: String!, $comment: String) {
+            createTeamVersion(tag: $tag, comment: $comment) {
+              ${TEAM_VERSION_FIELDS}
+            }
+          }
+        `, { tag, comment: comment ?? null })
+            .then(({ createTeamVersion }) => this.mapTeamVersion(createTeamVersion))
+            .catch((error) => {
+            return Promise.reject(this.cleanError(error));
+        });
+    }
+    deleteTeamVersion(tag) {
+        return this.client
+            .request((0, graphql_request_1.gql) `
+          mutation deleteTeamVersion($tag: String!) {
+            deleteTeamVersion(tag: $tag) {
+              ${TEAM_VERSION_FIELDS}
+            }
+          }
+        `, { tag })
+            .then(({ deleteTeamVersion }) => this.mapTeamVersion(deleteTeamVersion))
+            .catch((error) => {
+            return Promise.reject(this.cleanError(error));
+        });
+    }
+    allTeamVersionAliases() {
+        return this.client
+            .request((0, graphql_request_1.gql) `
+          query allTeamVersionAliases {
+            allTeamVersionAliases {
+              ${TEAM_VERSION_ALIAS_FIELDS}
+            }
+          }
+        `)
+            .then(({ allTeamVersionAliases }) => allTeamVersionAliases.map((alias) => this.mapTeamVersionAlias(alias)))
+            .catch((error) => {
+            return Promise.reject(this.cleanError(error));
+        });
+    }
+    /** The API upserts: an existing alias with the same name is re-pointed to the tag. */
+    createTeamVersionAlias(name, tag) {
+        return this.client
+            .request((0, graphql_request_1.gql) `
+          mutation createTeamVersionAlias($input: TeamVersionAliasInput!) {
+            createTeamVersionAlias(input: $input) {
+              ${TEAM_VERSION_ALIAS_FIELDS}
+            }
+          }
+        `, { input: { name, tag } })
+            .then(({ createTeamVersionAlias }) => this.mapTeamVersionAlias(createTeamVersionAlias))
+            .catch((error) => {
+            return Promise.reject(this.cleanError(error));
+        });
+    }
+    deleteTeamVersionAlias(id) {
+        return this.client
+            .request((0, graphql_request_1.gql) `
+          mutation deleteTeamVersionAlias($id: ID!) {
+            deleteTeamVersionAlias(id: $id) {
+              ${TEAM_VERSION_ALIAS_FIELDS}
+            }
+          }
+        `, { id })
+            .then(({ deleteTeamVersionAlias }) => this.mapTeamVersionAlias(deleteTeamVersionAlias))
+            .catch((error) => {
+            return Promise.reject(this.cleanError(error));
+        });
+    }
     team() {
         return this.client
             .request((0, graphql_request_1.gql) `

package/dist/utils/gitignore.d.ts

@@ -13,5 +13,7 @@ export declare function renderGitignoreWithInherited(existing: string, inherited
  * Refreshes the workspace .gitignore so inherited processes/modules (owned by a
  * parent team and pulled read-only) are not tracked by git. Regenerated from the
  * current workspace metadata, so resources that stop being inherited drop out.
+ * Inherited variable values live in one file, which is ignored as soon as the
+ * workspace inherits any variable.
  */
 export declare function syncInheritedGitignore(workspaceDir?: string): Promise<void>;

package/dist/utils/gitignore.js

@@ -6,6 +6,8 @@ exports.syncInheritedGitignore = syncInheritedGitignore;
 const path = require("node:path");
 const fs = require("fs-extra");
 const workspace_1 = require("../config/workspace");
+const global_1 = require("../config/global");
+const settings_1 = require("../config/settings");
 const filenamify_1 = require("./filenamify");
 const file_utils_1 = require("./file-utils");
 exports.INHERITED_BLOCK_START = '# BEGIN fcode inherited resources (auto-generated, do not edit)';
@@ -43,9 +45,12 @@ function stripManagedBlock(content) {
  * Refreshes the workspace .gitignore so inherited processes/modules (owned by a
  * parent team and pulled read-only) are not tracked by git. Regenerated from the
  * current workspace metadata, so resources that stop being inherited drop out.
+ * Inherited variable values live in one file, which is ignored as soon as the
+ * workspace inherits any variable.
  */
 async function syncInheritedGitignore(workspaceDir = process.cwd()) {
     const team = await new workspace_1.default(workspaceDir).getActiveTeam();
+    const inheritedVariablesFileName = await new global_1.default().getSetting(settings_1.SettingKeys.INHERITED_VARIABLES_FILE_NAME);
     const inheritedPaths = [
         ...Object.values(team.processes)
             .filter((process) => process.resolvingTeamSlug)
@@ -53,6 +58,7 @@ async function syncInheritedGitignore(workspaceDir = process.cwd()) {
         ...Object.values(team.modules)
             .filter((module) => module.resolvingTeamSlug)
             .map((module) => `modules/${(0, filenamify_1.default)(module.name)}/`),
+        ...(Object.values(team.variables ?? {}).some((variable) => variable.resolvingTeamSlug) ? [inheritedVariablesFileName] : []),
     ];
     const gitignorePath = path.join(workspaceDir, '.gitignore');
     const existing = fs.existsSync(gitignorePath) ? fs.readFileSync(gitignorePath, 'utf8') : '';