@factorialco/fcode-cli 3.5.0 → 3.6.0

package/dist/services/locale-resolver.js

@@ -71,16 +71,20 @@ function readLocale(workspaceDir, locale) {
         ...readLocaleFile(workspaceDir, locale),
     };
 }
-function chosenPrimaryLocaleOf(workspaceDir) {
+function primaryLocaleIn(workspaceDir, fileName) {
     try {
         (0, settings_1.migrateLegacySettingsFile)(workspaceDir);
-        const settings = fs.readJsonSync(path.join(workspaceDir, settings_1.SETTINGS_FILENAME));
+        const settings = fs.readJsonSync(path.join(workspaceDir, fileName));
         return typeof settings?.primaryLocale === 'string' && settings.primaryLocale.length > 0 ? settings.primaryLocale : undefined;
     }
     catch {
         return undefined;
     }
 }
+/** The workspace's own choice, or the one it inherits when settings.json makes none. */
+function chosenPrimaryLocaleOf(workspaceDir) {
+    return primaryLocaleIn(workspaceDir, settings_1.SETTINGS_FILENAME) ?? primaryLocaleIn(workspaceDir, settings_1.INHERITED_SETTINGS_FILENAME);
+}
 /** Every locale file in the workspace, own and inherited: `pull` writes them all to `i18n/`. */
 function localeFileSlugs(workspaceDir) {
     const directory = path.join(workspaceDir, I18N_DIRECTORY);
@@ -120,6 +124,20 @@ function matchingLocale(candidate, available) {
     }
     return available.filter((locale) => locale.toLowerCase() === candidate.toLowerCase()).sort()[0];
 }
+const LOCALE_SEPARATOR = /[-_]/;
+/**
+ * The available locale a bare language broadens to when the workspace only has regional files for
+ * it (`es` → `es-ES`): one whose first segment is the language, case ignored — the primary locale
+ * if it is one of them, the alphabetically first otherwise. A language with a separator in it (an
+ * identifier that starts with one) broadens to nothing. Mirrors the platform's `LocaleFallbackChain`.
+ */
+function sameLanguageLocale(language, primary, available) {
+    if (!language || LOCALE_SEPARATOR.test(language)) {
+        return undefined;
+    }
+    const sameLanguage = available.filter((locale) => locale.split(LOCALE_SEPARATOR)[0].toLowerCase() === language.toLowerCase()).sort();
+    return primary !== undefined && sameLanguage.includes(primary) ? primary : sameLanguage[0];
+}
 /**
  * The locale files that answer a requested identifier, lowest precedence first. Mirrors the
  * platform's `LocaleFallbackChain`, so a local run and the cloud resolve the same text.
@@ -128,7 +146,9 @@ function matchingLocale(candidate, available) {
  * publishes plain languages, so the request degrades one segment at a time — split on `-` or `_`,
  * without parsing a language tag, since any short slug is a legal identifier here — and every step
  * that matches stays in the chain: a variant file translates the keys that differ and leaves the
- * rest to the language it came from.
+ * rest to the language it came from. The opposite happens too — the host sends `es` while the
+ * workspace has `es-ES` — so a language layer that matches nothing, by name or ignoring case, is
+ * broadened to a regional file of that language, in the place the language would have taken.
  */
 function localeFallbackChain(requested, primary, available) {
     const chain = [];
@@ -146,8 +166,14 @@ function localeFallbackChain(requested, primary, available) {
         const lastSeparator = Math.max(candidate.lastIndexOf('-'), candidate.lastIndexOf('_'));
         candidate = lastSeparator > 0 ? candidate.slice(0, lastSeparator) : undefined;
     }
-    for (const shorterOrExact of candidates)
-        add(shorterOrExact);
+    candidates.forEach((shorterOrExact, index) => {
+        if (index === 0 && !matchingLocale(shorterOrExact, available)) {
+            add(sameLanguageLocale(shorterOrExact, primary, available));
+        }
+        else {
+            add(shorterOrExact);
+        }
+    });
     return chain;
 }
 /**
@@ -156,14 +182,15 @@ function localeFallbackChain(requested, primary, available) {
  * shorter form of the requested one the workspace publishes — layered underneath, plus each
  * locale's own map (inherited file layered under its own, but NOT merged over the primary) so a
  * call naming a locale (`fcode.i18n(key, args, { locale })`) resolves like the cloud's `by_locale`:
- * key by key in the requested locale first, falling back to the merged translations
+ * key by key in the requested locale first, falling back to the merged translations — and the
+ * primary locale, which a call naming a bare language prefers when it broadens to a regional file
  */
 function resolveLocalTranslations(requestedLocale, workspaceDir = process.cwd()) {
     const primary = primaryLocaleOf(workspaceDir);
     const locale = requestedLocale || primary;
     const byLocale = Object.fromEntries(availableLocales(workspaceDir).map((slug) => [slug, readLocale(workspaceDir, slug)]));
     if (!locale) {
-        return { locale: undefined, translations: {}, byLocale };
+        return { locale: undefined, primaryLocale: primary, translations: {}, byLocale };
     }
     // `byLocale` already holds every locale's own file, so the merged map — the fallback chain
     // layered lowest precedence first — is derived from it rather than read from disk a second time.
@@ -171,5 +198,5 @@ function resolveLocalTranslations(requestedLocale, workspaceDir = process.cwd())
     for (const layer of localeFallbackChain(requestedLocale, primary, Object.keys(byLocale))) {
         Object.assign(translations, byLocale[layer]);
     }
-    return { locale, translations, byLocale };
+    return { locale, primaryLocale: primary, translations, byLocale };
 }

package/dist/services/webhook-auth.d.ts

@@ -13,9 +13,11 @@ export type WebhookAuthResult = {
  */
 export declare function findHeader(headers: http.IncomingHttpHeaders, name: string): string | undefined;
 /**
- * The configuration a webhook actually enforces: its own when CUSTOM, the workspace's when TEAM.
+ * The configuration a webhook actually enforces: its own when CUSTOM, the workspace's when TEAM. The
+ * workspace's is its own (settings.json) or, when settings.json leaves it out, the inherited one
+ * (settings.inherited.json); null in settings.json clears it, a parent's included.
  * Returns null only when the webhook is public — TEAM without a workspace configuration throws,
  * because treating it as public would silently unprotect a webhook its owner chose to protect.
  */
-export declare function resolveEffectiveAuth(webhook: ProcessWebhook | undefined, teamWebhookAuth: WebhookAuth | undefined): WebhookAuth | null;
+export declare function resolveEffectiveAuth(webhook: ProcessWebhook | undefined, teamWebhookAuth: WebhookAuth | null | undefined, inheritedTeamWebhookAuth?: WebhookAuth): WebhookAuth | null;
 export declare function checkWebhookAuth(effectiveAuth: WebhookAuth | null, headers: http.IncomingHttpHeaders, variableValue: string | undefined): WebhookAuthResult;

package/dist/services/webhook-auth.js

@@ -26,20 +26,26 @@ function findHeader(headers, name) {
     return undefined;
 }
 /**
- * The configuration a webhook actually enforces: its own when CUSTOM, the workspace's when TEAM.
+ * The configuration a webhook actually enforces: its own when CUSTOM, the workspace's when TEAM. The
+ * workspace's is its own (settings.json) or, when settings.json leaves it out, the inherited one
+ * (settings.inherited.json); null in settings.json clears it, a parent's included.
  * Returns null only when the webhook is public — TEAM without a workspace configuration throws,
  * because treating it as public would silently unprotect a webhook its owner chose to protect.
  */
-function resolveEffectiveAuth(webhook, teamWebhookAuth) {
+function resolveEffectiveAuth(webhook, teamWebhookAuth, inheritedTeamWebhookAuth) {
     const authMode = webhook?.authMode;
     if (!authMode || authMode === 'NONE') {
         return null;
     }
     if (authMode === 'TEAM') {
-        if (!teamWebhookAuth) {
-            throw new Error('this webhook inherits the workspace webhook auth, which is not set in settings.json');
+        if (teamWebhookAuth === null) {
+            throw new Error('this webhook inherits the workspace webhook auth, which settings.json sets to none');
         }
-        return teamWebhookAuth;
+        const workspaceAuth = teamWebhookAuth ?? inheritedTeamWebhookAuth;
+        if (!workspaceAuth) {
+            throw new Error('this webhook inherits the workspace webhook auth, which is not set in settings.json nor inherited');
+        }
+        return workspaceAuth;
     }
     if (!webhook?.auth?.variableKey) {
         throw new Error('this webhook uses the CUSTOM auth mode but names no variable in metadata.json');

package/dist/utils/cli-version.d.ts

@@ -0,0 +1,7 @@
+/** The header the CLI reports its version in, so the platform can refuse a CLI too old for a request. */
+export declare const CLI_VERSION_HEADER = "Fcode-Cli-Version";
+/**
+ * The installed CLI's own version, read from its package.json: two levels above this file both in
+ * src/utils (tests) and dist/utils (the published package, which always ships package.json).
+ */
+export declare function cliVersion(): string;

package/dist/utils/cli-version.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CLI_VERSION_HEADER = void 0;
+exports.cliVersion = cliVersion;
+const fs = require("node:fs");
+const path = require("node:path");
+/** The header the CLI reports its version in, so the platform can refuse a CLI too old for a request. */
+exports.CLI_VERSION_HEADER = 'Fcode-Cli-Version';
+let cached;
+/**
+ * The installed CLI's own version, read from its package.json: two levels above this file both in
+ * src/utils (tests) and dist/utils (the published package, which always ships package.json).
+ */
+function cliVersion() {
+    if (cached === undefined) {
+        const packageJson = JSON.parse(fs.readFileSync(path.join(__dirname, '..', '..', 'package.json'), 'utf8'));
+        cached = String(packageJson.version);
+    }
+    return cached;
+}

package/dist/utils/gitignore.d.ts

@@ -16,6 +16,7 @@ export declare function renderGitignoreWithInherited(existing: string, inherited
  * 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; inherited locales are one file each, like modules;
- * inherited dependencies are one file per language, like variables.
+ * inherited dependencies are one file per language, like variables; inherited settings are one
+ * file.
  */
 export declare function syncInheritedGitignore(workspaceDir?: string): Promise<void>;

package/dist/utils/gitignore.js

@@ -9,6 +9,7 @@ const workspace_1 = require("../config/workspace");
 const global_1 = require("../config/global");
 const settings_1 = require("../config/settings");
 const programming_language_manifest_1 = require("../repositories/programming-language-manifest");
+const settings_2 = require("../repositories/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)';
@@ -51,7 +52,8 @@ function stripManagedBlock(content) {
  * 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; inherited locales are one file each, like modules;
- * inherited dependencies are one file per language, like variables.
+ * inherited dependencies are one file per language, like variables; inherited settings are one
+ * file.
  */
 async function syncInheritedGitignore(workspaceDir = process.cwd()) {
     const team = await new workspace_1.default(workspaceDir).getActiveTeam();
@@ -71,6 +73,8 @@ async function syncInheritedGitignore(workspaceDir = process.cwd()) {
         // inherit — checked on disk because the manifest metadata tracks the workspace's own list, not
         // what its parents contribute.
         ...exports.INHERITED_DEPENDENCY_FILES.filter((file) => fs.existsSync(path.join(workspaceDir, file))),
+        // Written only when the workspace inherits a setting, so checked on disk like dependencies.
+        ...(fs.existsSync(path.join(workspaceDir, settings_2.INHERITED_SETTINGS_FILENAME)) ? [settings_2.INHERITED_SETTINGS_FILENAME] : []),
     ];
     const gitignorePath = path.join(workspaceDir, '.gitignore');
     const existing = fs.existsSync(gitignorePath) ? fs.readFileSync(gitignorePath, 'utf8') : '';

package/oclif.manifest.json

@@ -2516,5 +2516,5 @@
       ]
     }
   },
-  "version": "3.5.0"
+  "version": "3.6.0"
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@factorialco/fcode-cli",
-  "version": "3.5.0",
+  "version": "3.6.0",
   "packageManager": "pnpm@11.7.0",
   "description": "Factorial Code Command Line Interface",
   "homepage": "https://code.factorialhr.com/docs/cli/",