fimo 0.2.4 → 0.2.5-experimental.1782327181771

package/assets/skills/fimo-cli/references/translations.md

@@ -1,43 +1,69 @@
-# Translations workflow
+# Labels workflow
 
-> For the `t()` helper signature, `useTranslations()` hook, key naming rules, and the "wrap every user-facing string" rule — these are package surface and code conventions. See **`fimo/references/translations.md`**.
+> For the `t()` helper signature, `useTranslations()` hook, key naming rules, and the "wrap every user-facing string" rule, see **`fimo/references/translations.md`**.
 
-This file covers the **CLI workflow** for translations.
+This file covers the **CLI workflow** for labels: static UI copy such as nav items, buttons, headings, placeholders, alt text, and SEO strings.
 
-## What sync does
+## What validate does
 
-The pre-build step scans `src/**/*.{ts,tsx,js,jsx}` for `t('literal-key', 'literal-default')` calls (skipping `src/ui` and `node_modules`), writes them to `translations/en.json`, and syncs them to the tenant DB. This makes strings editable inline by non-technical users in the Fimo admin and translatable to other locales.
+`fimo validate` scans `src/**/*.{ts,tsx,js,jsx}` for `t('literal-key')` calls (skipping `src/ui` and `node_modules`) and verifies every key has a value in the tenant DB for the default locale.
 
-Code is the source of truth for English defaults.
+The database is the source of truth for visible label values. Code declares keys; it does not create visible copy.
 
 ## CLI commands
 
 ```bash
-fimo validate                        # run all checks + sync local state to DB (includes translations)
-fimo translations list               # inspect what's currently in the DB (read-only)
-fimo translations list --locale en   # filter by locale
+fimo validate                         # run all checks; fails if label keys are missing in DB
+fimo labels list                      # inspect labels currently in the DB
+fimo labels list --locale en          # filter by locale
+fimo labels set nav.home --value Home # create/update one label
+fimo labels set-many --locale es --data '{"nav.home":"Inicio"}'
+fimo labels set-many --locale es --file /tmp/es-labels.json
+fimo labels delete nav.home --locale en
 ```
 
-`fimo validate` is the single entrypoint that extracts `t()` calls, rewrites `translations/en.json`, and pushes the diff to the DB. It's idempotent — run it as often as you like. It also runs automatically inside `fimo deploy`: `fimo validate` runs first (lint + codegen + DB sync), then any `translations/en.json` changes are committed and pushed alongside the rest of your code.
+There is no `fimo translations` command. Use `fimo labels`.
 
-Advanced/internal primitives (hidden from `fimo --help`, used for debugging or by the backend sandbox):
+## Locale config
+
+`fimo-config.json` controls label/content locales:
+
+```json
+{
+  "i18n": {
+    "defaultLocale": "en",
+    "locales": ["en", "es"],
+    "autoTranslateLabels": true,
+    "autoTranslateContent": true
+  }
+}
+```
+
+- `defaultLocale` is what `fimo validate` and label commands use when `--locale` is omitted.
+- `locales` is the enabled locale list and must include `defaultLocale`.
+- `autoTranslateLabels` defaults to enabled when omitted. Set it to `false` to stop default-locale label writes from enqueueing machine translations.
+- `autoTranslateContent` does the same for CMS/schema entries.
+- For a non-default locale, pass `--locale <locale>` explicitly.
+
+Advanced/internal primitive (hidden from `fimo --help`):
 
 ```bash
-fimo scripts extract-translations    # rewrite translations/en.json locally — no DB push
-fimo scripts inject-translations     # rewrite t() defaults in src/ to match translations/en.json
+fimo scripts extract-translations    # legacy helper: scan src/ for literal t() keys
 ```
 
-Prefer `fimo validate` — these primitives are for narrow use cases.
+Prefer `fimo validate` — this primitive is for narrow debugging/test use.
 
 ## When to run validate
 
-- After adding or changing any `t()` calls in code → run `fimo validate` (or rely on `fimo deploy` doing it for you).
-- After renaming/removing `t()` keys → the sync phase removes stale entries from the DB.
+- After adding or changing any `t()` keys in code, run `fimo validate`.
+- If validate reports `labels/missing`, add values with `fimo labels set` or `fimo labels set-many`, then run validate again.
+- After renaming/removing keys, clean old DB labels intentionally with `fimo labels delete` when they are no longer used.
 
 ## Workflow
 
-1. Write JSX with `t('key', 'Default')` calls. Load `fimo/references/translations.md` for the rules (literal keys, naming, what NOT to translate).
-2. Run `fimo validate` to push new keys to the DB.
-3. Editors can now change copy in the Fimo admin without code changes.
+1. Write JSX with `t('key')` calls. Load `fimo/references/translations.md` for the rules.
+2. Run `fimo validate`.
+3. Add missing values with `fimo labels set` or `fimo labels set-many`.
+4. Editors can now change copy in the Fimo admin without code changes.
 
 For the helper signatures, hooks, and code patterns, **always** load `fimo/references/translations.md` before writing code that uses `t()`.

package/dist/build/vite/plugins/fimo-config.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"fimo-config.d.ts","sourceRoot":"","sources":["../../../../src/build/vite/plugins/fimo-config.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,MAAM,CAAC;AAKnC;;;;;;;;GAQG;AACH,MAAM,CAAC,OAAO,UAAU,gBAAgB,IAAI,MAAM,CAsCjD"}
+{"version":3,"file":"fimo-config.d.ts","sourceRoot":"","sources":["../../../../src/build/vite/plugins/fimo-config.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,MAAM,CAAC;AAKnC;;;;;;;;GAQG;AACH,MAAM,CAAC,OAAO,UAAU,gBAAgB,IAAI,MAAM,CA6CjD"}

package/dist/build/vite/plugins/fimo-config.js

@@ -38,6 +38,13 @@ export default function fimoConfigPlugin() {
                 return 'export default {};';
             }
         },
+        transformIndexHtml(html) {
+            const lang = readHtmlLang(configPath);
+            if (/<html\b[^>]*\blang=/.test(html)) {
+                return html.replace(/(<html\b[^>]*\blang=["'])[^"']*(["'])/i, `$1${lang}$2`);
+            }
+            return html.replace(/<html\b([^>]*)>/i, `<html$1 lang="${lang}">`);
+        },
         handleHotUpdate(ctx) {
             if (ctx.file !== configPath) {
                 return;
@@ -50,3 +57,12 @@ export default function fimoConfigPlugin() {
         },
     };
 }
+function readHtmlLang(configPath) {
+    try {
+        const raw = JSON.parse(readFileSync(configPath, 'utf-8'));
+        return (raw.seo?.locale ?? raw.i18n?.defaultLocale ?? 'en').replace('_', '-');
+    }
+    catch {
+        return 'en';
+    }
+}

package/dist/build/vite/plugins/fimo-config.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=fimo-config.test.d.ts.map

package/dist/build/vite/plugins/fimo-config.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"fimo-config.test.d.ts","sourceRoot":"","sources":["../../../../src/build/vite/plugins/fimo-config.test.ts"],"names":[],"mappings":""}

package/dist/build/vite/plugins/fimo-config.test.js

@@ -0,0 +1,46 @@
+import { mkdtempSync, rmSync, writeFileSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+import { afterEach, describe, expect, it } from 'vitest';
+import fimoConfigPlugin from './fimo-config';
+let scratch = null;
+const pluginContext = {
+    meta: {},
+    error: (error) => {
+        throw error;
+    },
+    info: () => undefined,
+    warn: () => undefined,
+    debug: () => undefined,
+};
+afterEach(() => {
+    if (scratch) {
+        rmSync(scratch, { recursive: true, force: true });
+        scratch = null;
+    }
+});
+function createPluginWithConfig(config) {
+    scratch = mkdtempSync(join(tmpdir(), 'fimo-config-plugin-'));
+    writeFileSync(join(scratch, 'fimo-config.json'), JSON.stringify(config, null, 2));
+    const plugin = fimoConfigPlugin();
+    if (typeof plugin.config === 'function') {
+        plugin.config.call(pluginContext, { root: scratch }, { command: 'build', mode: 'production' });
+    }
+    return plugin;
+}
+function transformHtml(plugin, html) {
+    if (typeof plugin.transformIndexHtml !== 'function') {
+        throw new Error('Expected transformIndexHtml function');
+    }
+    return plugin.transformIndexHtml.call(pluginContext, html, {});
+}
+describe('fimoConfigPlugin', () => {
+    it('sets html lang from seo.locale first', () => {
+        const plugin = createPluginWithConfig({ seo: { locale: 'es_ES' }, i18n: { defaultLocale: 'fr' } });
+        expect(transformHtml(plugin, '<html><head></head><body></body></html>')).toContain('<html lang="es-ES">');
+    });
+    it('falls back to i18n.defaultLocale when seo.locale is absent', () => {
+        const plugin = createPluginWithConfig({ i18n: { defaultLocale: 'fr' } });
+        expect(transformHtml(plugin, '<html lang="en"><head></head><body></body></html>')).toContain('<html lang="fr">');
+    });
+});

package/dist/build/vite/plugins/translations.d.ts

@@ -1,9 +1,10 @@
 import type { Plugin } from 'vite';
-/**
- * Provides the `virtual:translations` module — `useTranslations()` reads
- * its data from this. Source: `<projectRoot>/translations/en.json`.
- *
- * Edits to that JSON trigger HMR on consumers via `handleHotUpdate`.
- */
+interface LabelBundle {
+    labels: Record<string, string>;
+    locale: string;
+    updatedAt: string | null;
+}
 export default function translationsPlugin(): Plugin;
+export declare function loadLabelBundle(rootDir: string): Promise<LabelBundle>;
+export {};
 //# sourceMappingURL=translations.d.ts.map

package/dist/build/vite/plugins/translations.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"translations.d.ts","sourceRoot":"","sources":["../../../../src/build/vite/plugins/translations.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,MAAM,CAAC;AAEnC;;;;;GAKG;AACH,MAAM,CAAC,OAAO,UAAU,kBAAkB,IAAI,MAAM,CA0DnD"}
+{"version":3,"file":"translations.d.ts","sourceRoot":"","sources":["../../../../src/build/vite/plugins/translations.ts"],"names":[],"mappings":"AAKA,OAAO,KAAK,EAAE,MAAM,EAAiB,MAAM,MAAM,CAAC;AAOlD,UAAU,WAAW;IACnB,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IAC/B,MAAM,EAAE,MAAM,CAAC;IACf,SAAS,EAAE,MAAM,GAAG,IAAI,CAAC;CAC1B;AAuBD,MAAM,CAAC,OAAO,UAAU,kBAAkB,IAAI,MAAM,CAmMnD;AA8BD,wBAAsB,eAAe,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO,CAAC,WAAW,CAAC,CAkC3E"}

package/dist/build/vite/plugins/translations.js

@@ -1,22 +1,76 @@
+import { createHash } from 'node:crypto';
+import { Buffer } from 'node:buffer';
 import { readFile } from 'node:fs/promises';
+import { homedir } from 'node:os';
 import { join } from 'node:path';
-/**
- * Provides the `virtual:translations` module — `useTranslations()` reads
- * its data from this. Source: `<projectRoot>/translations/en.json`.
- *
- * Edits to that JSON trigger HMR on consumers via `handleHotUpdate`.
- */
+import { getConfigServer } from '../../../runtime/shared/fimo-config.server.js';
+const VIRTUAL_ID = 'virtual:translations';
+const RESOLVED_ID = '\0' + VIRTUAL_ID;
 export default function translationsPlugin() {
-    const VIRTUAL_ID = 'virtual:translations';
-    const RESOLVED_ID = '\0' + VIRTUAL_ID;
     let rootDir = process.cwd();
-    let translationsPath;
+    let bundle = { labels: {}, locale: 'en', updatedAt: null };
+    let command = 'build';
+    let devServer = null;
+    let eventSockets = [];
+    let reconnectTimer;
+    let refreshTimer;
+    let pollTimer;
+    const refreshLabels = async () => {
+        bundle = await loadLabelBundle(rootDir);
+        return bundle;
+    };
+    const refreshLabelsAndInvalidateIfChanged = async () => {
+        const before = serializeBundle(bundle);
+        const next = await refreshLabels();
+        if (serializeBundle(next) !== before) {
+            invalidateLabels();
+        }
+    };
+    const invalidateLabels = () => {
+        if (!devServer) {
+            return;
+        }
+        for (const mod of findVirtualTranslationModules(devServer)) {
+            devServer.moduleGraph.invalidateModule(mod);
+        }
+        devServer.ws.send({ type: 'full-reload', path: '*' });
+    };
+    const scheduleRefresh = () => {
+        if (refreshTimer) {
+            clearTimeout(refreshTimer);
+        }
+        refreshTimer = setTimeout(() => {
+            void refreshLabelsAndInvalidateIfChanged().catch(() => undefined);
+        }, 150);
+    };
     return {
         name: 'fimo-virtual-translations',
         enforce: 'pre',
         configResolved(config) {
             rootDir = config.root;
-            translationsPath = join(rootDir, 'translations', 'en.json');
+            command = config.command;
+        },
+        async buildStart() {
+            bundle = emptyLabelBundle(rootDir);
+            this.addWatchFile(join(rootDir, 'fimo-config.json'));
+            this.addWatchFile(join(rootDir, '.env'));
+            this.addWatchFile(join(rootDir, '.env.local'));
+            if (command === 'build') {
+                await refreshLabels();
+            }
+        },
+        configureServer(server) {
+            devServer = server;
+            server.watcher.add([join(rootDir, 'fimo-config.json'), join(rootDir, '.env'), join(rootDir, '.env.local')]);
+            void refreshLabelsAndInvalidateIfChanged().catch(() => undefined);
+            connectLabelEvents(rootDir, scheduleRefresh)
+                .then((sockets) => {
+                eventSockets = sockets;
+            })
+                .catch(() => undefined);
+            pollTimer = setInterval(() => {
+                void refreshLabelsAndInvalidateIfChanged().catch(() => undefined);
+            }, 2000);
         },
         resolveId(id) {
             if (id === VIRTUAL_ID) {
@@ -28,34 +82,313 @@ export default function translationsPlugin() {
             if (id !== RESOLVED_ID) {
                 return null;
             }
-            // For now, only English. Read from project translations/en.json
-            const filePath = translationsPath || join(rootDir, 'translations', 'en.json');
-            // Watch the JSON file so edits trigger HMR
-            this.addWatchFile(filePath);
-            let json = '{}';
-            try {
-                json = await readFile(filePath, 'utf8');
-                if (!json || json.trim() === '') {
-                    json = '{}';
-                }
+            const current = command === 'serve' ? bundle : await refreshLabels();
+            const labels = JSON.stringify(current.labels);
+            return [
+                `export const translations = ${labels};`,
+                `export const labels = translations;`,
+                `export const locale = ${JSON.stringify(current.locale)};`,
+                `export const updatedAt = ${JSON.stringify(current.updatedAt)};`,
+                `export const signature = ${JSON.stringify(labelSignature(current.labels))};`,
+            ].join('\n');
+        },
+        async handleHotUpdate(ctx) {
+            const watched = new Set([join(rootDir, 'fimo-config.json'), join(rootDir, '.env'), join(rootDir, '.env.local')]);
+            if (!watched.has(ctx.file)) {
+                return;
             }
-            catch {
-                json = '{}';
+            await refreshLabels();
+            const modules = findVirtualTranslationModules(ctx.server);
+            if (modules.length > 0) {
+                for (const mod of modules) {
+                    ctx.server.moduleGraph.invalidateModule(mod);
+                }
+                return modules;
             }
-            // Expose as a flat map
-            return `export const translations = ${json};`;
+            return [];
         },
-        handleHotUpdate(ctx) {
-            // Invalidate the virtual module when the JSON changes
-            const watched = translationsPath || join(rootDir, 'translations', 'en.json');
-            if (ctx.file !== watched) {
-                return;
+        closeBundle() {
+            for (const socket of eventSockets) {
+                socket.close();
+            }
+            eventSockets = [];
+            if (reconnectTimer) {
+                clearTimeout(reconnectTimer);
+            }
+            if (refreshTimer) {
+                clearTimeout(refreshTimer);
             }
-            const mod = ctx.server.moduleGraph.getModuleById(RESOLVED_ID);
-            if (mod) {
-                ctx.server.moduleGraph.invalidateModule(mod);
-                return [mod];
+            if (pollTimer) {
+                clearInterval(pollTimer);
             }
         },
     };
+    async function connectLabelEvents(root, onLabelsChanged) {
+        const env = await readProjectEnv(root);
+        const apiUrl = env.VITE_API_URL;
+        if (!apiUrl) {
+            return [];
+        }
+        const runtimeConfig = await loadRuntimeConfig(apiUrl);
+        const eventsUrl = runtimeConfig.eventsServerUrl ?? undefined;
+        if (!eventsUrl) {
+            return [];
+        }
+        const settings = await readProjectSettings(root);
+        if (!settings.projectId) {
+            return [];
+        }
+        const WebSocketCtor = globalThis.WebSocket;
+        if (!WebSocketCtor) {
+            return [];
+        }
+        const sockets = [];
+        for (const room of deriveEventsRooms(settings.projectId, apiUrl)) {
+            const token = await generateOneTimeToken(settings.apiUrl ?? process.env.FIMO_API_URL ?? 'http://localhost:3000');
+            const wsUrl = new URL(`/parties/events/${room}`, eventsUrl.replace(/^http/, 'ws'));
+            wsUrl.searchParams.set('authToken', token);
+            const socket = new WebSocketCtor(wsUrl.toString());
+            socket.onmessage = (event) => {
+                const raw = typeof event.data === 'string' ? event.data : '';
+                if (!raw) {
+                    return;
+                }
+                try {
+                    const message = JSON.parse(raw);
+                    if (message.type !== 'labels:changed') {
+                        return;
+                    }
+                    const changedLocales = message.payload?.changes?.map((change) => change.locale).filter(Boolean) ?? [];
+                    if (changedLocales.length === 0 || changedLocales.includes(bundle.locale)) {
+                        onLabelsChanged();
+                    }
+                }
+                catch {
+                    return;
+                }
+            };
+            socket.onclose = () => {
+                reconnectTimer = setTimeout(() => {
+                    void connectLabelEvents(root, onLabelsChanged)
+                        .then((nextSockets) => {
+                        eventSockets = nextSockets;
+                    })
+                        .catch(() => undefined);
+                }, 2000);
+            };
+            socket.onerror = () => undefined;
+            sockets.push(socket);
+        }
+        return sockets;
+    }
+}
+function serializeBundle(bundle) {
+    return JSON.stringify({ labels: bundle.labels, locale: bundle.locale });
+}
+function emptyLabelBundle(rootDir) {
+    const config = getConfigServer(rootDir);
+    return {
+        labels: {},
+        locale: config.i18n?.defaultLocale ?? 'en',
+        updatedAt: null,
+    };
+}
+function findVirtualTranslationModules(server) {
+    const direct = server.moduleGraph.getModuleById(RESOLVED_ID);
+    const matches = new Set(direct ? [direct] : []);
+    for (const mod of server.moduleGraph.idToModuleMap.values()) {
+        if (mod.id?.includes('virtual:translations')) {
+            matches.add(mod);
+        }
+    }
+    return [...matches];
+}
+function labelSignature(labels) {
+    return Buffer.from(JSON.stringify(labels)).toString('base64');
+}
+export async function loadLabelBundle(rootDir) {
+    const config = getConfigServer(rootDir);
+    const locale = config.i18n?.defaultLocale ?? 'en';
+    const env = await readProjectEnv(rootDir);
+    const apiUrl = env.VITE_API_URL;
+    if (!apiUrl) {
+        return { labels: {}, locale, updatedAt: null };
+    }
+    try {
+        const url = new URL('/labels', apiUrl);
+        url.searchParams.set('locale', locale);
+        const response = await fetchWithTimeout(url, 4000);
+        if (!response.ok) {
+            return { labels: {}, locale, updatedAt: null };
+        }
+        const body = (await response.json());
+        if (Array.isArray(body.data)) {
+            return {
+                labels: Object.fromEntries(body.data.map((row) => [row.key, row.value ?? row.defaultValue ?? ''])),
+                locale,
+                updatedAt: null,
+            };
+        }
+        return {
+            labels: body.data?.labels ?? {},
+            locale,
+            updatedAt: body.data?.updatedAt ?? null,
+        };
+    }
+    catch {
+        return { labels: {}, locale, updatedAt: null };
+    }
+}
+async function loadRuntimeConfig(apiUrl) {
+    try {
+        const response = await fetchWithTimeout(new URL('/runtime-config', apiUrl), 2000);
+        if (!response.ok) {
+            return {};
+        }
+        const body = await response.json();
+        return parseRuntimeConfig(body);
+    }
+    catch {
+        return {};
+    }
+}
+function parseRuntimeConfig(body) {
+    if (!body || typeof body !== 'object') {
+        return {};
+    }
+    const envelopeData = body.data;
+    const source = envelopeData && typeof envelopeData === 'object' ? envelopeData : body;
+    const eventsServerUrl = source.eventsServerUrl;
+    return {
+        eventsServerUrl: typeof eventsServerUrl === 'string' ? eventsServerUrl : undefined,
+    };
+}
+async function fetchWithTimeout(url, timeoutMs) {
+    const controller = new AbortController();
+    const timeout = setTimeout(() => controller.abort(), timeoutMs);
+    try {
+        return await fetch(url, { signal: controller.signal });
+    }
+    finally {
+        clearTimeout(timeout);
+    }
+}
+async function readProjectEnv(rootDir) {
+    const values = {
+        ...(await readEnvFile(join(rootDir, '.env'))),
+        ...(await readEnvFile(join(rootDir, '.env.local'))),
+    };
+    for (const key of ['VITE_API_URL']) {
+        if (process.env[key]) {
+            values[key] = process.env[key];
+        }
+    }
+    return values;
+}
+async function readEnvFile(filePath) {
+    try {
+        const content = await readFile(filePath, 'utf8');
+        const values = {};
+        for (const line of content.split(/\r?\n/)) {
+            const trimmed = line.trim();
+            if (!trimmed || trimmed.startsWith('#')) {
+                continue;
+            }
+            const index = trimmed.indexOf('=');
+            if (index === -1) {
+                continue;
+            }
+            const key = trimmed.slice(0, index).trim();
+            const value = trimmed
+                .slice(index + 1)
+                .trim()
+                .replace(/^['"]|['"]$/g, '');
+            values[key] = value;
+        }
+        return values;
+    }
+    catch {
+        return {};
+    }
+}
+async function readProjectSettings(rootDir) {
+    try {
+        const raw = await readFile(join(rootDir, '.fimo.settings.json'), 'utf8');
+        return JSON.parse(raw);
+    }
+    catch {
+        return {};
+    }
+}
+function deriveEventsRooms(projectId, tenantApiUrl) {
+    const rooms = new Set([projectId]);
+    try {
+        const firstLabel = new URL(tenantApiUrl).hostname.split('.')[0];
+        if (firstLabel.startsWith(`${projectId}-`)) {
+            rooms.add(`${projectId}:${firstLabel.slice(projectId.length + 1)}`);
+        }
+    }
+    catch {
+        return [...rooms];
+    }
+    return [...rooms];
+}
+async function generateOneTimeToken(apiUrl) {
+    const bearer = process.env.FIMO_API_TOKEN?.trim() || (await readStoredToken(apiUrl));
+    if (!bearer) {
+        throw new Error('Not signed in to Fimo.');
+    }
+    const response = await fetch(new URL('/api/auth/one-time-token/generate', apiUrl), {
+        method: 'POST',
+        headers: {
+            Authorization: `Bearer ${bearer}`,
+        },
+    });
+    if (!response.ok) {
+        throw new Error(`Failed to generate events auth token: ${response.status}`);
+    }
+    const body = (await response.json());
+    const token = body.token ?? body.data?.token;
+    if (!token) {
+        throw new Error('Events auth token response did not include a token.');
+    }
+    return token;
+}
+async function readStoredToken(apiUrl) {
+    const configDir = join(process.env.XDG_CONFIG_HOME || join(homedir(), '.config'), 'fimo');
+    const credentialsFile = join(configDir, 'credentials', credentialsFilename(apiUrl));
+    try {
+        const raw = await readFile(credentialsFile, 'utf8');
+        const parsed = JSON.parse(raw);
+        return parsed.access_token ?? null;
+    }
+    catch {
+        return null;
+    }
+}
+function credentialsFilename(apiUrl) {
+    const normalized = normalizeApiUrl(apiUrl);
+    let hostLabel = 'unknown';
+    try {
+        hostLabel = new URL(normalized).host
+            .replace(/:/g, '-')
+            .replace(/[^a-zA-Z0-9.-]+/g, '-')
+            .replace(/^[.-]+|[.-]+$/g, '')
+            .toLowerCase();
+    }
+    catch {
+        hostLabel = 'unknown';
+    }
+    return `${hostLabel || 'unknown'}-${createHash('sha256').update(normalized).digest('hex').slice(0, 6)}.json`;
+}
+function normalizeApiUrl(input) {
+    const trimmed = input.trim();
+    try {
+        const url = new URL(trimmed);
+        const pathname = url.pathname.replace(/\/+$/, '');
+        return `${url.protocol}//${url.host}${pathname}`;
+    }
+    catch {
+        return trimmed.replace(/\/+$/, '');
+    }
 }

package/dist/build/vite/plugins/translations.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=translations.test.d.ts.map

package/dist/build/vite/plugins/translations.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"translations.test.d.ts","sourceRoot":"","sources":["../../../../src/build/vite/plugins/translations.test.ts"],"names":[],"mappings":""}