@factorialco/fcode-cli 2.0.0 → 2.2.0

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:
@@ -64,6 +64,7 @@ fcode = FcodeGlobal(
     Storage(),
     Schedule(),
     Variables(env_variables),
+    metadata.get("i18n", {}),
 )
 
 logging.basicConfig(level=os.environ.get("FCODE_LOG_LEVEL", logging.INFO))

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

@@ -78,8 +78,42 @@ class Processes(dict):
             print(error, file=sys.stderr)
 
 
+class I18n:
+    """Local equivalent of the cloud's fcode.i18n.
+
+    The CLI has already layered the chosen locale over the workspace's primary one, so what
+    arrives here is a single flat map. Nothing raises: a key with no translation resolves to the
+    key itself, and a placeholder with no argument is left exactly as written.
+
+    The ``options`` argument (the version a call pins in the cloud) is accepted and ignored: a
+    workspace directory holds no published snapshots, so a pinned call resolves against the files
+    on disk -- the same per-file fallback the cloud applies to a locale never published at that tag.
+    """
+
+    def __init__(self, i18n_payload):
+        payload = i18n_payload or {}
+        self.__translations = payload.get("translations") or {}
+        self.locale = payload.get("locale")
+
+    def __call__(self, key, args=None, options=None):
+        template = self.__translations.get(key)
+        if template is None:
+            return key
+        if not isinstance(args, dict):
+            return template
+
+        import re
+
+        def replace(match):
+            value = args.get(match.group(1).strip())
+            return match.group(0) if value is None else str(value)
+
+        # Single pass, so a substituted value containing %{...} is never rescanned.
+        return re.sub(r"%\{([^}]*)\}", replace, template)
+
+
 class FcodeGlobal:
-    def __init__(self, context, execution, env, datastore, storage, schedule, variables):
+    def __init__(self, context, execution, env, datastore, storage, schedule, variables, i18n=None):
         self.context = context
         self.execution = execution
         self.team = AttrsInfo({"timezone": "UTC"})
@@ -89,6 +123,7 @@ class FcodeGlobal:
         self.schedule = schedule
         self.variables = variables
         self.processes = Processes()
+        self.i18n = I18n(i18n)
 
     def send_mail(self, to=None, subject=None, text=None, html=None):
         # No manager locally: log the email contents instead of sending, so devs
@@ -110,6 +145,13 @@ class FcodeGlobal:
         return {"messageId": "local-run", "accepted": accepted, "rejected": []}
 
     def import_module(self, module_name, version=None):
+        """Import a workspace module, optionally at a version.
+
+        The version is either a bare string or an options dict ({"version": "v1"}), the form
+        every other versioned helper takes — the cloud reads both, so a local run must too.
+        """
+        if isinstance(version, dict):
+            version = version.get("version")
         module_path = module_name
         if version:
             module_path = os.path.join(module_path, "versions", 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 { Locale, Process, ProgrammingLanguage, ProgrammingLanguageManifest, RawTeamSettings, ScriptLibrary, TeamUpdateInput, TeamVersion, TeamVersionAlias, Variable, VersionedProcess, VersionedScriptLibrary, ServiceAccount } from '../core/types';
 export type FcodeGraphQLClientOptions = {
     url: string;
     accessToken: string;
@@ -22,6 +22,16 @@ declare class FcodeGraphQLClient {
     allVersionedScriptLibraries(scriptLibraryId: string): Promise<Array<VersionedScriptLibrary>>;
     createVersionedScriptLibrary(versionedScriptLibrary: VersionedScriptLibrary): Promise<void>;
     allVariables(): Promise<Array<Variable>>;
+    /**
+     * Every locale the workspace resolves: its own files, plus one merged file per identifier it
+     * inherits. A locale the workspace and a parent both define is listed twice by the platform and
+     * kept twice here — an override is layered over the parent's file key by key, so the parent's
+     * keys are still what the ones it does not mention resolve to.
+     */
+    allLocales(): Promise<Array<Locale>>;
+    pushLocale(locale: Locale): Promise<Locale>;
+    updateLocale(locale: Locale): Promise<Locale>;
+    removeLocale(locale: string | undefined): Promise<void>;
     private toProcessInput;
     pushProcess(process: Process): Promise<Process>;
     removeProcess(id: String | undefined): Promise<Process>;
@@ -44,6 +54,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;