fimo 0.9.0-experimental.1 → 0.9.0

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

@@ -29,7 +29,7 @@ fimo projects rename <name> [projectId] [-C <dir>]   # local-only: set seo.siteN
 fimo clone [projectId] [dir] [--env <name>] # same as `fimo projects clone`
 ```
 
-Use the top-level shortcut for the common "get this project onto my machine" workflow. After clone succeeds, `cd` into the printed directory and load the newly written project context (`AGENTS.md` plus the installed project skill) before generating code.
+Use the top-level shortcut for the common "get this project onto my machine" workflow. After clone succeeds, `cd` into the printed directory, `Read` the project's `AGENTS.md`, and load the code skill with `npx fimo@latest skills get fimo-code` before generating code.
 
 ## Top-level shortcuts (current project)
 

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

@@ -4,20 +4,22 @@
 
 `fimo support report` sends a project-scoped problem to Fimo support. It automatically includes the project, current environment, and CLI version so support can start investigating without asking the user to repeat that context.
 
-## When to offer it
+## When to prepare it
 
-Offer to report when:
+Prepare a report proactively when:
 
 - A Fimo command, API, preview, deploy, sandbox, or platform operation repeatedly fails or returns an unexpected response.
 - A documented or previously working API or CLI argument is rejected, ignored, or behaves differently from its contract.
 - A supported operation only works through an undocumented workaround or an unnecessarily complex sequence.
 - A Fimo API repeatedly times out or is abnormally slow enough to disrupt the workflow.
-- A missing Fimo capability blocks completion, forces a fragile or heavily manual workaround, or would materially accelerate recurring work. Bulk creation replacing many single-item calls is a good example.
+- A confirmed missing Fimo capability blocks completion or forces a fragile or heavily manual workaround.
 - The remaining problem or capability gap appears to be in Fimo rather than the user's application code.
 
 For failures, read the error and try one safe, relevant recovery step before reporting. Feature requests do not need a failed recovery attempt; confirm that the capability is actually absent.
 
-Do not report ordinary application bugs, small conveniences, vague wishlist items, one-off latency, or failures you have not inspected. A clearly documented unsupported capability is still worth reporting when its absence crosses the blocking or material-acceleration threshold above; describe it as a feature request rather than a bug.
+Do not interrupt the user's main work to prepare a report. Complete it, use a safe workaround, or preserve progress first. Then use the built-in `supportReport` tool without waiting for the user to request it. Do not stop after merely describing the Fimo problem or gap.
+
+Do not report ordinary application bugs, small conveniences, vague wishlist items, one-off latency, speculative gaps, or failures you have not inspected. A clearly documented unsupported capability is still worth reporting when its absence crosses the blocking threshold above; describe it as a feature request rather than a bug.
 
 ## What to write
 
@@ -33,22 +35,22 @@ Keep the report factual and short:
 
 Do not include secrets, environment values, raw shell history, hidden reasoning, full source files, or unrelated conversation history.
 
-## Required approval
+## Sending
+
+Agents should use the built-in `supportReport` tool after the main work is complete or safely preserved. The tool submits through this CLI command and records the normal tool activity in chat.
 
-Prepare the report, then preview the complete payload without sending it:
+To inspect the exact CLI payload manually without sending it:
 
 ```bash
 fimo support report --message-file /tmp/fimo-support-report.md --preview --json
 ```
 
-Show the user the exact `data.message` from that output. Submit only after the user explicitly approves it:
+To send non-interactively:
 
 ```bash
 fimo support report --message-file /tmp/fimo-support-report.md --yes --json
 ```
 
-`--yes` means the report has already been reviewed and approved. Never pass it preemptively or report automatically.
-
 For a person using an interactive terminal:
 
 ```bash

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

@@ -47,7 +47,7 @@ Omit `--body` to send this full envelope. Prefer that default when the receiver
 Store credentials as project secrets, never literal header flags:
 
 ```bash
-printf '%s' "$RESEND_API_KEY" | fimo secrets set RESEND_API_KEY --stdin
+printf '%s' "$RESEND_API_KEY" | fimo secrets add RESEND_API_KEY --stdin
 
 fimo webhooks create waitlist-resend \
   --event form.submitted \
@@ -57,6 +57,8 @@ fimo webhooks create waitlist-resend \
   --body '{"email":"{{ event.data.submission.data.email }}"}'
 ```
 
+`fimo secrets add` refuses to replace an existing value. Use `fimo secrets update` for an intentional rotation.
+
 Header sources:
 
 - `Name=secret:KEY`: secret is the complete value

package/assets/skills/fimo-code/SKILL.md

@@ -0,0 +1,67 @@
+---
+name: fimo-code
+description: >-
+  How to write code in a Fimo project — the npm package surface. Load when
+  writing JSX that renders schema content, defining schemas or forms (JSON),
+  using `t()` for labels, plugging media into `fimo/ui` components,
+  or applying the project's code conventions. CLI commands and workflows
+  (push, deploy, sync, etc.) live in the `fimo-cli` skill.
+---
+
+# Fimo
+
+You are writing code in a Fimo project — a content + media + forms + analytics platform for React websites with a CMS dashboard. This skill describes the **`fimo` npm package surface** as installed in this specific project: what's exported from `fimo`, `fimo/ui`, `fimo/vite`; the JSON shapes you write; the generated React Query hooks and Zod schemas you import; and the code conventions for using them.
+
+This skill is version-locked to this project's installed `fimo` package — the shapes here match what your code can actually use.
+
+For CLI commands and workflows (creating a project, pushing schemas/forms, deploying, managing labels, etc.), the **`fimo-cli`** skill is the source of truth. Run every CLI command as `npx fimo@latest <command>` (always the latest, no global install). Load it on demand with `npx fimo@latest skills get fimo-cli`.
+
+## Critical: NEVER hardcode user-facing things
+
+This is the load-bearing rule for every code change. **Fimo's whole point is that content editors edit content in the dashboard, not in code.** Anything hardcoded breaks that.
+
+- **Content** (posts, products, pages, lists, anything structured) → declare a schema, render collections with generated `useList()` or `useInfiniteList()` hooks + `fimo/ui` components. Use `useGet()` only for legacy fixed array queries. **Never** write `const posts = [...]` in JSX.
+- **Strings** (labels, CTAs, headings, descriptions, any visible text) → wrap in `t('key')` and create the default-locale value with `fimo labels set`. Use `--locale <locale>` only when intentionally writing a non-default locale. **Never** write `<h1>Welcome</h1>` directly — write `<Text value={t('home.title')} as="h1" />`.
+- **Media** (images, videos, files) → use `<Image>` / `<Video>` from `fimo/ui` for schema media, `<StaticImage>` for hard-coded URLs. **Never** use `<img src={...}>`.
+- **Forms** → use the generated Zod schema + `submitX` helper from `@/forms/<name>`. Never hand-roll fetch or validation.
+
+If you find yourself about to hardcode anything user-facing, **stop and use the appropriate Fimo primitive instead.** For pushing the schema/form/asset to the backend, that's CLI territory — see the `fimo-cli` skill.
+
+## When starting code work, load these references up front
+
+These define the package surface for the load-bearing primitives. **Read all six before generating significant code:**
+
+- `references/content.md` — schema JSON shape, field types, Tiptap nodes, generated React Query hooks
+- `references/forms.md` — form JSON spec, generated Zod + `submitX` helper
+- `references/assets.md` — `FimoMedia` shape, how to render assets
+- `references/labels.md` — `t()` helper, `useLabels()`, wrap rules
+- `references/locales.md` — locale routing helpers, `FimoLink`, custom-framework contract
+- `references/ui.md` — `fimo/ui` components + JSX code conventions + app code rules
+
+Workflow / CLI-side concerns (pushing schemas, generating images, managing labels, deploying) live in the **`fimo-cli`** skill's matching references.
+
+## Decision Tree (specific tasks)
+
+- **Setting up Fimo in a new project** — pick the framework:
+  - React Router framework mode (new projects use React Router 8) → `references/setup-react-router.md`
+  - Plain Vite + React (or upgrading a legacy v3 project) → `references/setup-plain-vite.md`
+- Writing schema JSON / picking field types / Tiptap richtext → `references/content.md`
+- Writing form JSON / generated form client / form code → `references/forms.md`
+- Plugging media into a component / `FimoMedia` shape → `references/assets.md`
+- ANY user-facing string in code → `references/labels.md`
+- Locale-aware routes, links, or framework adapters → `references/locales.md`
+- ANY JSX rendering schema content or `t()` output → `references/ui.md`
+- Major visual / redesign / hero section / brand → `references/design.md`
+
+## Anti-Patterns
+
+- **Hardcoding content in JSX** — `<h1>My Blog</h1>` + an array of posts in code. Use schemas + entries + `t()`.
+- **Raw HTML for schema content** — `<img src={post.coverImage.url}>` instead of `<Image value={post.coverImage}>`. The `fimo/ui` components carry metadata for inline editing in the admin.
+- **Raw `<a href>` for internal navigation** — causes full page reloads. Use `<FimoLink>` for locale-aware internal links or React Router `<Link>` when intentionally bypassing locale helpers. Reserve `<a>` for external links.
+- **Pulling stock photos from external URLs** — editors can't manage them. Use a Fimo media task such as `fimo image generate`.
+- **Editing generated `.ts` files** under `src/schemas/` or `src/forms/` — regenerate them through `fimo validate` or the matching push command.
+- **Writing raw HTML in `richtext` fields** — must be Tiptap JSONContent.
+- **Calling `t()` with a dynamic first argument** — the key must be a string literal so the extractor finds it.
+- **Decorating the disposable starter** — `src/pages/Index.tsx` is throwaway scaffolding. On first real generation, replace it entirely.
+- **Skipping legal pages** — `Privacy.tsx` + `Terms.tsx` are required for public sites; the template ships them.
+- **Showing Fimo branding** in the generated site unless the user explicitly asks for it.

package/assets/skills/fimo-migration/SKILL.md

@@ -17,10 +17,7 @@ exports, source repositories, CMS exports, media folders, or any hybrid of those
 It owns intake, source inventory, URL crawl bootstrapping, ledger normalization,
 imports, and QA so any LLM can run the work without silently dropping content.
 
-> Run every `fimo` command as `npx fimo <command>` when the project declares a
-> `fimo` dependency (adopted/wrapped projects pin an exact version tied to their
-> backend — never override it with `@latest`). Only fall back to
-> `npx fimo@latest` when the project has no `fimo` dependency.
+> Run every `fimo` command as `npx fimo@latest <command>` — always the latest CLI, no global install.
 
 ## Non-Negotiables
 
@@ -33,13 +30,6 @@ imports, and QA so any LLM can run the work without silently dropping content.
   ledger.
 - Source exports beat inferred crawls. If CSV/XML/JSON exports, media folders, or
   source code exist, treat the public URL as visual/SEO reference only.
-- A working JS codebase is wrapped, not rewritten. Wrap mode
-  (`references/wrap.md`) keeps the user's routing, styling, and components
-  untouched; the diff is wiring + wrappers + config only. As the coding
-  agent you own the whole wrap loop — run `npx fimo migrate` yourself and
-  follow `references/wrap.md` § W0 (relay the recorded data-source
-  decisions to the user, then loop `npx fimo migrate wrap --check` to
-  exit 0).
 - Builder HTML is evidence, not the final runtime. Rebuild with Fimo conventions,
   schemas, forms, media primitives, translations, and routes.
 - Do not report completion until the QA gate passes or every failed check is
@@ -69,15 +59,7 @@ imports, and QA so any LLM can run the work without silently dropping content.
      pack.
    - **hybrid**: source files plus public URL. Use source-backed as truth and URL
      for route, SEO, visual, and behavior comparison.
-4. Pick the mode:
-   - **wrap** (default for a source-backed, working JS codebase — Next.js,
-     Vite/React, React Router): keep the user's stack, adopt the repo with
-     `fimo init`, and make content editable by wrapping it in place. Never
-     rewrite routing, styling, or components. Follow `references/wrap.md`.
-   - **rebuild**: url-only sources, builder exports/HTML dumps, non-JS
-     backends, or codebases that do not build. Follow the standard workflow
-     phases.
-5. Create or update the canonical ledger described in
+4. Create or update the canonical ledger described in
    `references/manifest.md`.
 
 ## Workflow
@@ -114,8 +96,6 @@ node <this-skill>/scripts/write-migration-report.mjs <project-root>
 ## References
 
 - `references/workflow.md` - full decision tree and phase order.
-- `references/wrap.md` - wrap mode: adopt a working JS codebase and wrap its
-  content in place (default for source-backed JS sites).
 - `references/manifest.md` - canonical migration ledger schema.
 - `references/content.md` - CMS, entries, references, and source value rules.
 - `references/media.md` - media inventory, upload, dedupe, and replacement rules.

package/assets/skills/fimo-migration/references/content.md

@@ -18,14 +18,6 @@ ways:
    news teasers, and feature lists are almost always collections even when the
    source renders them inside one page.
 
-> **Rebuild path only.** These rules apply when Fimo re-authors the site
-> (URL/export migrations): the rebuilt code is disposable, so content belongs
-> in collections aggressively. **Wrap mode is deliberately stricter** — the
-> user's code stays primary, page furniture and nav stay in code with `t()`
-> labels, and every collection candidate is confirmed with the user first.
-> See `wrap.md` (W0 and the generated agent-prompt) — in wrap mode that
-> guidance overrides this section.
-
 After the source-faithful rebuild, treat **any hardcoded array of 3+ items with
 the same shape** as a collection candidate. Do not leave it hardcoded.
 
@@ -105,19 +97,3 @@ Skipped fields or entries require a manifest note with:
 - reason
 - owner impact
 - suggested action
-
-## Scaffolded CMS — verify pages render
-
-When `fimo migrate --scaffold-cms` wires the site to Fimo, the machine does the
-deterministic work: it maps the CMS's components and dynamic zones to editable
-Fimo blocks, seeds every block with generic example content in the shape the
-components expect, and swaps the client's fetch for the generated Fimo adapter —
-so the whole site reads from Fimo with no per-view wiring.
-
-The last mile is yours and it is per-site. Open the main pages in `pnpm dev` (a
-list, a detail, the page-builder home) and confirm each renders. Every renderer is
-the site's own code, so a component may read a field the generic content did not
-fill, or expect a slightly different shape. Where a section renders blank or
-throws, fix it at that component — a defensive default, or the field it truly
-needs — and re-check. Record anything you cannot resolve as a caveat. Do not
-re-scaffold, re-wire, or hand-wrap content; the machine owns those.

package/assets/skills/fimo-migration/references/manifest.md

@@ -34,7 +34,6 @@ follow-up agents, and import/QA checks.
   "seo": [],
   "unsupported": [],
   "unresolved": [],
-  "wrap": null,
   "qa": {
     "status": "not-run|passed|failed|passed-with-unresolved",
     "checks": []
@@ -42,40 +41,6 @@ follow-up agents, and import/QA checks.
 }
 ```
 
-## Wrap Block (wrap mode only)
-
-When the migration is a wrap (see `references/wrap.md`), set
-`source.mode: "source-backed"` and fill the `wrap` block; leave it `null` for
-rebuild migrations:
-
-```json
-{
-  "wrap": {
-    "mode": "wrap",
-    "framework": "next|react-router|vite",
-    "adopted": true,
-    "wired": true,
-    "coverage": {
-      "wrappable": 0,
-      "wrapped": 25,
-      "ignored": 0,
-      "unresolvedItems": 0
-    },
-    "seeded": {
-      "labels": 21,
-      "wrappedMedia": 3,
-      "wrappedRichText": 1
-    },
-    "planPath": ".fimo/migration/plan.json"
-  }
-}
-```
-
-`coverage` mirrors the final `fimo migrate wrap --check` output: `wrappable`
-must be 0 (or fully accounted for by `ignored` + `unresolvedItems`, each with a
-ledger entry). `seeded` counts must match what `fimo labels list` /
-`fimo entries list` report — fallback-only content is not seeded.
-
 ## Required Item Fields
 
 Every route, content type, entry batch, media asset, form, redirect, locale, SEO

package/assets/skills/fimo-migration/references/qa.md

@@ -18,11 +18,8 @@ Run this gate before reporting completion.
 ## Behavior
 
 - Dependencies are installed in the target project.
-- The project builds successfully **with its own toolchain** (`next build`,
-  `vite build`, …) — wrapped sites are not Vite/React-Router projects; never
-  assume Fimo-template tooling.
-- Local dev starts without loader/schema/form generation errors (Vite errors
-  apply to rebuild-mode projects only).
+- The project builds successfully.
+- Local dev starts without Vite loader/schema/form generation errors.
 - Primary routes render without console/runtime errors.
 - Collection listing/detail pages work with imported data, seed data, or explicit
   empty states.
@@ -36,25 +33,6 @@ Run this gate before reporting completion.
 - Remove generated placeholder copy from visible UI.
 - Verify media aspect ratios and no broken images on primary routes.
 
-## Wrap Mode (additional blocking checks)
-
-When the manifest says `mode: "wrap"`:
-
-- `fimo migrate wrap --check` exits zero — it enforces coverage (zero
-  unwrapped items), render parity (rendered text/marks/media/links identical
-  to the pre-wrap baseline), and seeding (every wrapped key exists in the
-  database) — or every remaining item is an explicit ignored/unresolved
-  ledger entry with a reason.
-- Labels are seeded: every `FimoText`/`t()` key exists in `fimo labels list`
-  with the original string. Fallback-only content fails the gate.
-- Wrapped media/rich text have their `WrappedMedia`/`WrappedRichText` entries
-  created and assets uploaded.
-- Render parity: pages render identically to pre-migration — same text, same
-  formatting marks (bold/italic/underline/links), same media.
-- Diff audit: the migration diff contains only wiring, wrappers, label calls,
-  config, and dependency changes. Any routing/styling/component rewrite fails
-  the gate.
-
 ## Import Verification
 
 Record:

package/assets/skills/fimo-migration/references/workflow.md

@@ -2,14 +2,6 @@
 
 Use this as the phase contract for complete migrations.
 
-> **Mode fork.** For a source-backed, WORKING JS codebase (Next.js, Vite/React,
-> React Router), wrap mode is the default: skip Phases 0 and 6 below and follow
-> `references/wrap.md` (adopt via `fimo init`, scan via `fimo migrate wrap`,
-> wrap in place, seed, verify). Phases 3–5 (content model, media/forms, import)
-> and Phase 8 (QA + report) still apply — wrap changes how content becomes
-> editable, not the accounting obligations. Everything else here is the rebuild
-> path.
-
 ## Phase 0: Target Safety
 
 1. Confirm the target path.
@@ -127,10 +119,7 @@ Required order:
 Record target IDs, import counts, failures, and unresolved items in the
 canonical ledger. Generated JSON without import counts is still draft state.
 
-## Phase 6: Fimo Implementation (rebuild mode)
-
-In wrap mode this phase is replaced by `references/wrap.md` phases W3–W5
-(wire, wrap, seed); do not rebuild pages for a wrapped site.
+## Phase 6: Fimo Implementation
 
 Implement routes, schemas, forms, entries, media, redirects, translations, and
 React pages with Fimo conventions.

package/assets/skills/fimo-studio/references/visual-editing.md

@@ -12,9 +12,7 @@ For text elements, the side panel shows editable fields where you can change the
 
 ### Editing Styles
 
-Style controls are only available on projects created before July 2026. Newer projects edit styles through the AI chat instead (for example: "make the hero title larger and dark blue"). If the user does not see the style controls described below, their project is a newer one -- point them to the chat.
-
-On projects that have them, the side panel organizes style controls into these categories:
+The side panel organizes style controls into these categories:
 
 - **Typography** -- Font family, font size, font weight, line height, letter spacing, text alignment, and bold/italic/underline/strikethrough toggles.
 - **Color** -- Text and foreground colors.
@@ -33,5 +31,5 @@ Click the **Edit mode** toggle again or close the side panel. The side editor cl
 
 ## When to Use Edit Mode vs. Chat
 
-- **Edit mode** is best for content changes -- updating text (including bold, italic, underline, and links), and replacing images. On older projects it also covers quick style tweaks like colors and spacing.
-- **Chat** is better for style and structural changes -- changing colors or spacing (on newer projects), adding new sections, restructuring a page layout, or building new functionality.
+- **Edit mode** is best for quick visual tweaks -- changing a color, adjusting spacing, updating text, or trying a different font.
+- **Chat** is better for bigger changes -- adding new sections, restructuring a page layout, or building new functionality.

package/assets/skills/fimo-studio/references/webhooks.md

@@ -29,7 +29,7 @@ When Studio recognizes a Resend, Slack, or GitHub URL, it offers a request setup
 
 ## Add authentication
 
-Under **Headers**, add a header name and choose its value type. Prefer a project secret for API keys and tokens; choose whether the destination needs the raw secret, a `Bearer ` prefix, or a `token ` prefix. Fixed values are suitable only for non-sensitive headers.
+Under **Headers**, add a header name and type any non-secret prefix, such as `Bearer `. Choose **Insert secret** to select an existing project secret or create one without leaving the webhook editor. Creating a secret never replaces an existing secret with the same name; select the existing secret instead. Fixed values are suitable only for non-sensitive headers.
 
 Fimo signs requests by default. Save the signing secret shown after creation so a custom receiver can verify `X-Fimo-Signature`. Rotate it from the webhook configuration if it is exposed.
 

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

@@ -1,5 +1,11 @@
 import type { Plugin } from 'vite';
-import { loadLabelBundle } from '../../../runtime/shared/labels-fetch.server.js';
+interface LabelBundle {
+    dictionaries: Record<string, Record<string, string>>;
+    defaultLocale: string;
+    locales: string[];
+    updatedAt: string | null;
+}
 export default function translationsPlugin(): Plugin;
-export { loadLabelBundle };
+export declare function loadLabelBundle(rootDir: string): Promise<LabelBundle>;
+export {};
 //# sourceMappingURL=translations.d.ts.map

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

@@ -1,8 +1,10 @@
 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';
-import { emptyLabelBundle, labelSignature, loadLabelBundle, readProjectEnv, resolveTenantApiUrl, serializeBundle, } from '../../../runtime/shared/labels-fetch.server.js';
+import { getFimoDefaultLocale, getFimoLocales } from '../../../runtime/i18n/locale.js';
+import { getConfigServer } from '../../../runtime/shared/fimo-config.server.js';
 const VIRTUAL_ID = 'virtual:translations';
 const RESOLVED_ID = '\0' + VIRTUAL_ID;
 export default function translationsPlugin() {
@@ -143,7 +145,7 @@ export default function translationsPlugin() {
     };
     async function connectLabelEvents(root, onLabelsChanged) {
         const env = await readProjectEnv(root);
-        const apiUrl = resolveTenantApiUrl(env);
+        const apiUrl = env.VITE_API_URL;
         if (!apiUrl) {
             return [];
         }
@@ -227,6 +229,24 @@ function parseContentChangePayload(payload) {
         updatedAt: typeof source.updatedAt === 'string' ? source.updatedAt : undefined,
     };
 }
+function serializeBundle(bundle) {
+    return JSON.stringify({
+        dictionaries: bundle.dictionaries,
+        defaultLocale: bundle.defaultLocale,
+        locales: bundle.locales,
+    });
+}
+function emptyLabelBundle(rootDir) {
+    const config = getConfigServer(rootDir);
+    const defaultLocale = getFimoDefaultLocale(config);
+    const locales = getFimoLocales(config);
+    return {
+        dictionaries: Object.fromEntries(locales.map((locale) => [locale, {}])),
+        defaultLocale,
+        locales,
+        updatedAt: null,
+    };
+}
 function findVirtualTranslationModules(server) {
     const direct = server.moduleGraph.getModuleById(RESOLVED_ID);
     const matches = new Set(direct ? [direct] : []);
@@ -237,13 +257,73 @@ function findVirtualTranslationModules(server) {
     }
     return [...matches];
 }
+function labelSignature(bundle) {
+    return Buffer.from(serializeBundle(bundle)).toString('base64');
+}
 function labelUpdatePayload(bundle) {
     return {
         ...bundle,
         signature: labelSignature(bundle),
     };
 }
-export { loadLabelBundle };
+export async function loadLabelBundle(rootDir) {
+    const config = getConfigServer(rootDir);
+    const defaultLocale = getFimoDefaultLocale(config);
+    const locales = getFimoLocales(config);
+    const env = await readProjectEnv(rootDir);
+    const apiUrl = env.VITE_API_URL;
+    if (!apiUrl) {
+        return {
+            dictionaries: Object.fromEntries(locales.map((locale) => [locale, {}])),
+            defaultLocale,
+            locales,
+            updatedAt: null,
+        };
+    }
+    try {
+        const loaded = await Promise.all(locales.map((locale) => fetchLabelDictionary(apiUrl, locale).catch(() => ({ locale, labels: {}, updatedAt: null }))));
+        const updatedAt = loaded
+            .map((entry) => entry.updatedAt)
+            .filter((value) => typeof value === 'string')
+            .sort()
+            .at(-1);
+        return {
+            dictionaries: Object.fromEntries(loaded.map((entry) => [entry.locale, entry.labels])),
+            defaultLocale,
+            locales,
+            updatedAt: updatedAt ?? null,
+        };
+    }
+    catch {
+        return {
+            dictionaries: Object.fromEntries(locales.map((locale) => [locale, {}])),
+            defaultLocale,
+            locales,
+            updatedAt: null,
+        };
+    }
+}
+async function fetchLabelDictionary(apiUrl, locale) {
+    const url = new URL('/labels', apiUrl);
+    url.searchParams.set('locale', locale);
+    const response = await fetchWithTimeout(url, 4000);
+    if (!response.ok) {
+        return { locale, labels: {}, updatedAt: null };
+    }
+    const body = (await response.json());
+    if (Array.isArray(body.data)) {
+        return {
+            locale,
+            labels: Object.fromEntries(body.data.map((row) => [row.key, row.value ?? row.defaultValue ?? ''])),
+            updatedAt: null,
+        };
+    }
+    return {
+        locale,
+        labels: body.data?.labels ?? {},
+        updatedAt: body.data?.updatedAt ?? null,
+    };
+}
 async function loadRuntimeConfig(apiUrl) {
     try {
         const response = await fetchWithTimeout(new URL('/runtime-config', apiUrl), 2000);
@@ -278,6 +358,44 @@ async function fetchWithTimeout(url, timeoutMs) {
         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');

package/dist/cli/bundle.json

@@ -1,8 +1,8 @@
 {
   "bundled": true,
   "bundler": "esbuild",
-  "bundledAt": "2026-07-23T17:15:28.604Z",
-  "cliVersion": "0.8.0",
+  "bundledAt": "2026-07-24T11:14:53.290Z",
+  "cliVersion": "0.9.0",
   "external": [
     "oxc-parser",
     "fsevents",