fimo 0.10.0 → 0.10.1-staging.1

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

@@ -5,7 +5,7 @@ description: >-
   Load when the user wants to create a new Fimo project, build content
   (schemas, entries, forms, media, labels/locales), deploy a site, manage
   custom domains, configure outbound webhooks and event-driven integrations,
-  check site traffic/analytics, invite collaborators, inspect AI credits,
+  check site traffic/analytics, inspect or restore project history, invite collaborators, inspect AI credits,
   report a failing or slow Fimo API, rejected documented argument,
   undocumented workaround, missing capability that blocks work, forces a
   fragile or heavily manual workaround, or would materially accelerate a
@@ -62,6 +62,7 @@ npx fimo@latest clone                          # interactively choose an existin
 cd my-site                                     # then load skills on demand: npx fimo@latest skills get fimo-code
 pnpm dev                                       # run the app locally (use the project's PM: pnpm/npm run/yarn/bun) — your iteration loop
 npx fimo@latest credits                        # inspect the owning org's AI credit balance (read-only)
+npx fimo@latest history list                   # inspect this environment's restore points
 npx fimo@latest validate                       # run all checks + codegen; fails on missing DB labels
 npx fimo@latest deploy                         # ON-DEMAND: hosted preview / shareable link (runs validate internally)
 npx fimo@latest deploy --publish               # ON-DEMAND: publish live (only when the developer says "ship it")
@@ -92,6 +93,7 @@ Load the matching reference when the user's request fires its trigger. Recipes t
 - "Enable provider tools / integrations / API key connection for a provider / agent integration access" → `references/integrations.md`
 - "Firecrawl / scrape a public website / competitor research / agent web research" → `references/integrations.md` **+ load `references/integrations/firecrawl.md`**
 - "Check credits / credit balance / can I keep using AI / billing credits / running low / how many credits are left" → `references/credits.md`
+- "List history / create a restore point / recover content and code / restore a previous version / snapshot usage or retention" → `references/history.md`
 - "Create a branch / feature environment / new env / switch envs / merge envs / diff two envs / env status / what changed on this branch / sync from parent / cut a release / tag a version / go to prod" → `references/branches.md`
 - "List my projects / clone an existing project locally / check out a project / delete this project / unpublish / rename the project / manage projects across the org" → `references/projects.md`
 - "Migrate an existing Webflow / Framer / Squarespace / Wix / Carrd site from only a published URL" → load the `fimo-migration` skill and start with `fimo migrate <url> [dir]` to prepare the agent-ready migration draft

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

@@ -0,0 +1,40 @@
+# Project History
+
+> **Run via `npx fimo@latest <command>`** — always the latest CLI, no install needed.
+
+History is scoped to the selected project environment. A restore point records the environment's CMS content and the matching Git commit so code and content can be recovered together.
+
+```bash
+fimo history list
+fimo history show <version-id>
+fimo history create "Before content migration"
+fimo history restore <version-id>
+```
+
+Use the global `--env <name>` option to target a different environment. Use `--project <id>` when there is no local `.fimo.settings.json`.
+
+## Pagination and usage
+
+`fimo history list` returns 20 restore points by default. Use `--limit <1-100>` to change the page size. When another page exists, the output includes the exact next command and its opaque cursor:
+
+```bash
+fimo history list --limit 20 --cursor <cursor>
+```
+
+The list also reports compressed snapshot usage and the current retention period. Restore points expire after 14 days on Free and pay-as-you-go plans, or 90 days on Premium. The expiry is fixed when each point is created.
+
+## Restore safety
+
+Before replacing code and content, Fimo creates an automatic `restore-safety` point from the environment's current state. Restoring that point is the fast recovery path when the selected result is not what the user expected.
+
+Pretty mode asks for confirmation. Agents and other non-interactive callers must pass both `--json` and `--yes`:
+
+```bash
+fimo --json history restore <version-id> --yes
+```
+
+If another history create, update, delete, or restore is already running, the command fails with `HISTORY_BUSY`. Retry after the active history operation finishes. Do not loop without a delay.
+
+If content or Git restore does not finish cleanly, the command fails with `RESTORE_INCOMPLETE` and names the automatic safety point. Stop active editing, inspect the environment, and retry the restore. Collaborative-editor resync continues in the background after code and content are ready.
+
+Normal CMS edits, Git pushes, and unsaved collaborative-editor changes do not take the history-operation lock. Avoid starting a restore while someone is actively editing the same environment.

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

@@ -1,48 +1,71 @@
 # Scheduled Commands
 
-> **Run via `npx fimo@latest <command>`** — always the latest CLI, no install needed.
+> **Run via `npx fimo@latest <command>`** - always the latest CLI, no install needed.
 
-`fimo schedules` manages recurring commands for a project env. A schedule is scoped to the env of the current checkout by default, or to `--env <name>` when passed.
+`fimo schedules` manages recurring commands for one project environment. It uses the current checkout environment by default, or the environment passed with `--env <name>`.
+
+The command starts in that environment's sandbox. Commands can still target another environment explicitly, for example with `fimo schemas list --env preview`.
 
 ## Commands
 
 ```bash
-fimo schedules create <name> --cron "0 2 * * *" --do "fimo publish"
-fimo schedules create smoke --cron "*/15 * * * *" --do "pnpm test"
+fimo schedules create <name> --cron "0 2 * * *" --do "fimo validate"
+fimo schedules create <name> --cron "0 2 * * *" --do "pnpm sync" --secret CMS_TOKEN --secret SEARCH_KEY
 fimo schedules list
-fimo schedules run <name>
-fimo schedules delete <name>
+fimo schedules show <schedule>
+fimo schedules update <schedule> --cron "0 3 * * *" --secret CMS_TOKEN
+fimo schedules update <schedule> --clear-secrets
+fimo schedules pause <schedule>
+fimo schedules resume <schedule>
+fimo schedules run <schedule>
+fimo schedules run <schedule> --no-wait
+fimo schedules runs <schedule> --limit 25 --status failed
+fimo schedules runs <schedule> --all
+fimo schedules runs show <run-id>
+fimo schedules delete <schedule>
 ```
 
-## Runtime Model
+`<schedule>` accepts a schedule ID or an exact schedule name. Name-based commands resolve the name in the active environment and then use the stable schedule ID.
+
+## Runtime model
+
+Scheduled commands run in the project's environment runtime, not on the user's machine. Fimo prepares the environment and executes the stored command from the project root.
 
-Scheduled commands run in the project's env runtime, not on the user's machine. On each run, Fimo prepares the env, refreshes the project files and dependencies, authenticates as the schedule owner, then executes the stored command from the project root.
+`--do` can be any command that works with schedule runtime permissions, such as `fimo validate`, `pnpm test`, or a project script. The runtime can edit project content and publish or unpublish the project, but it cannot manage project access, secrets, schedules, or other project-level settings.
 
-`--do` can be any CLI command that makes sense for the project, such as `fimo publish`, `fimo validate`, `pnpm test`, or a project script.
+Runs use at-least-once delivery. If Fimo loses a completion response, the same run may execute again. Side-effecting commands should use `FIMO_SCHEDULE_RUN_ID` as their idempotency key.
 
 Cron expressions use standard five-field syntax. Schedules must not run more often than every five minutes.
 
-## Useful Patterns
+## Project secrets
 
-Nightly publish:
+Repeat `--secret KEY` to expose selected project secrets to a scheduled command. Creating a schedule without `--secret` exposes no project secrets. Updating with one or more `--secret` flags replaces the selected key names. Use `--clear-secrets` to remove every selected key; it cannot be combined with `--secret`.
 
-```bash
-fimo schedules create nightly --cron "0 2 * * *" --do "fimo publish"
-```
+Schedule and run output shows secret key names and snapshot state only. It never returns secret values.
 
-Recurring smoke test:
+## Runs
 
-```bash
-fimo schedules create smoke --cron "*/15 * * * *" --do "pnpm test"
-```
+`fimo schedules run` queues a manual run, prints its run ID, and waits for the run to finish. Use `--no-wait` to return as soon as it is queued.
+
+Only one run for a schedule can be active at a time. If a run is already queued or running, the command returns `run_in_progress` with the active run ID.
 
-Manual run without waiting for cron:
+Run history is cursor-paginated:
 
 ```bash
-fimo schedules run smoke
+fimo schedules runs nightly --limit 50
+fimo schedules runs nightly --cursor <cursor>
+fimo schedules runs nightly --status succeeded
+fimo schedules runs nightly --all
 ```
 
+Run detail includes status, timing, trigger, exit/error information, retained output, output retention metadata, and secret snapshot metadata. Output is capped and redacted before it is returned.
+
+## JSON
+
+All schedule commands support the CLI's global `--json` mode. List and run-history responses preserve the API page shape, including `items`, `nextCursor`, `usage`, and `policy`.
+
 ## Notes
 
-- `list`, `run`, and `delete` operate on the current checkout env unless `--env` is passed.
-- A failed command marks the schedule `failed`, stores the error/log excerpt, and `fimo schedules run` exits non-zero.
+- Every operation is scoped to the active environment unless `--env` is passed.
+- Pausing stops future cron runs. It does not delete history.
+- A failed or skipped manual run exits non-zero with its run ID and an exact `runs show` command for inspecting detail.

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

@@ -6,8 +6,8 @@ description: >-
   Triggers: "in Fimo Studio", "in the dashboard", "in the web app",
   "how do I X in the UI", or screenshots of the dashboard. Topics
   covered: dashboard content and CMS, publishing from the dashboard,
-  dashboard SEO/domain settings, outbound webhooks, visual editing, version
-  history UI, dashboard sharing/billing, and dashboard chat. Never describe
+  dashboard SEO/domain settings, schedules and run history, outbound webhooks,
+  visual editing, version history UI, dashboard sharing/billing, and dashboard chat. Never describe
   UI locations, buttons, or panels from memory — always read the relevant
   reference file first.
 ---
@@ -37,6 +37,7 @@ Read the relevant reference file when the user's question matches a topic.
 | AI Chat                  | references/ai-chat.md                   | "What can the AI do?", "How do I give context?"       |
 | Code Editor              | references/code-editor.md               | "How do I edit code?", "Where are my files?"          |
 | SEO Settings             | references/seo-settings.md              | "How do I set up SEO?", "Favicon, title, share image" |
+| Schedules                | references/schedules.md                 | "Recurring commands", "Run history", "Run now"        |
 | Webhooks                 | references/webhooks.md                  | "React to forms", "Send events to another service"    |
 | Preview & Responsive     | references/preview-and-responsive.md    | "How does it look on mobile?", "How do I test sizes?" |
 | Visual Editing           | references/visual-editing.md            | "Can I edit visually?", "How do I change colors?"     |
@@ -55,6 +56,7 @@ Read the relevant reference file when the user's question matches a topic.
 | Adding images           | Media Library, AI Chat, Edit Mode                                              |
 | Content/CMS             | AI Chat, Media Library                                                         |
 | Webhooks                | Project secrets, Forms, Publishing, Agents                                     |
+| Schedules               | Project secrets, Environments, Agents                                          |
 | Visual changes          | Edit Mode (quick tweaks), AI Chat (bigger changes), Code Editor (full control) |
 | Something went wrong    | Version History, AI Chat                                                       |
 | Working with others     | Sharing, Collaboration                                                         |

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

@@ -0,0 +1,43 @@
+# Schedules
+
+Schedules run recurring project commands in one environment. Use the Studio surface to review configuration, pause or resume automatic runs, start work now, and inspect what happened afterward.
+
+## Open schedules
+
+1. Open the project and choose **Settings**.
+2. Select **Schedules**.
+3. Choose the environment whose schedules you want to manage.
+
+The list shows each schedule's name, cron, command, enabled state, and latest status. Usage and retention policy are shown for the selected environment.
+
+## Create or edit a schedule
+
+Choose **New schedule** to set:
+
+- A human-readable name
+- A standard five-field cron expression
+- The command to run from the project root
+- The project secret keys the command is allowed to use
+
+A schedule with no selected secret keys receives no project secrets. Studio displays key names only and never reveals secret values.
+
+Open a schedule to change its configuration. Use **Pause** to prevent future cron runs without deleting its history, and **Resume** to make the cron active again.
+
+## Run now
+
+Choose **Run now** from a schedule to queue a manual run. Only one run can be active for a schedule at a time. If one is already queued or running, Studio links to the active run instead of starting a duplicate.
+
+Runs use at-least-once delivery. If Fimo loses a completion response, the same run may execute again. Side-effecting commands should use `FIMO_SCHEDULE_RUN_ID` as their idempotency key.
+
+## Inspect history
+
+Open the **Runs** tab on a schedule to browse cursor-paginated history. Filter by queued, running, succeeded, failed, or skipped status.
+
+Select a run to see:
+
+- Status, trigger, actor, and queued/start/finish times
+- Exit code, stable error code, and error message
+- Redacted captured output, its size, truncation state, and expiry
+- Secret snapshot state and key metadata
+
+Secret snapshot metadata helps explain whether a selected key was resolved, missing, deleted, recreated, or rotated after the run. It never contains a secret value or hash.

package/assets/skills/fimo-studio/references/version-history.md

@@ -1,25 +1,23 @@
 ## Where to Find Version History
 
-Click your **project name** in the top of the left sidebar to open the project dropdown menu, then select **History**. This opens the version history panel showing all your saved versions.
+Click your **project name** in the top bar to open the project dropdown menu, then select **History**. This opens the version history panel showing all your saved versions.
 
 ## How Versions Are Created
 
-Versions are created automatically as you work — you don't create them by hand. Whenever the AI makes meaningful changes to your project, it captures a snapshot you can browse, rename, and restore. There is no "create version" button in the panel; the history list only shows the snapshots that already exist.
+Versions are created automatically as you work — you don't create them by hand. Whenever the AI makes meaningful changes to your project, it captures a restore point for the current environment that you can browse, rename, and restore. A restore point includes the project code and CMS data, including schemas, entries, translations, and forms. There is no "create version" button in the panel; the history list only shows the restore points that already exist.
 
 ## Browsing Versions
 
 The version list shows each version's name and timestamp (the relative time, with the full date on hover).
 
-- The most recent version shows a **"Current"** badge.
-
 ## Restoring a Previous Version
 
 1. Find the version you want to restore.
 2. Click the **three-dot menu** next to the version and select **Restore**.
-3. A confirmation dialog appears warning that this will replace your current project.
+3. A confirmation dialog explains that this will replace the current environment and save its current state as a safety point first.
 4. Click **Restore** to confirm.
 
-Your project reverts to that version.
+The current environment's code and CMS data revert to that restore point. Uploaded assets do not change. If you need to undo the restore, restore the automatically created safety point.
 
 ## Editing Version Details
 
@@ -28,12 +26,14 @@ Find the version you want to update, click the **three-dot menu**, select **Edit
 ## Key Concepts
 
 - **Automatic versions** -- The AI creates these whenever it makes significant changes to your project. You do not need to do anything for these to appear.
-- **Rename, don't create** -- You can't add a version yourself, but you can rename any existing version (via the three-dot menu → **Edit**) to make it easier to find later.
-- **Restoring replaces everything** -- When you restore a version, it replaces all files in your project, not just the last change. This is a full rollback.
+- **Studio is browse and restore** -- Studio does not create restore points manually. Developers can use `fimo history create "Name"` from the CLI.
+- **Environment-scoped history** -- Each environment has its own restore points. Restoring one environment does not change another.
+- **Safe restore** -- Fimo records the current code and CMS data as a safety point before replacing them.
+- **Assets stay in place** -- Restoring changes code and CMS data, but does not remove or roll back uploaded assets.
 
 ## Quick Restore from Chat
 
-Each AI message in the chat that made changes to your project shows an **undo button** (↩ icon) on the right side. Click it and a **"Restore version?"** prompt appears; confirm it to restore your project to the state it was in at that message. This is the fastest way to undo a recent change without opening the full version history panel.
+Each AI message in the chat that made changes to your project shows an **undo button** (↩ icon) on the right side. Click it and a **"Restore version?"** prompt appears; confirm it to restore the current environment to the state it was in at that message. Fimo saves a safety point first, so CMS work completed after that message remains recoverable. This is the fastest way to undo a recent change without opening the full version history panel.
 
 The undo button is disabled on the most recent change (you can't restore the version you're already on) and is only available to members with permission to manage history.
 

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

@@ -7,15 +7,24 @@ import { getFimoDefaultLocale, getFimoLocales } from '../../../runtime/i18n/loca
 import { getConfigServer } from '../../../runtime/shared/fimo-config.server.js';
 const VIRTUAL_ID = 'virtual:translations';
 const RESOLVED_ID = '\0' + VIRTUAL_ID;
+const EVENT_RECONNECT_DELAY_MS = 2000;
+const FALLBACK_POLL_INTERVAL_MS = 30_000;
 export default function translationsPlugin() {
     let rootDir = process.cwd();
-    let bundle = { dictionaries: { en: {} }, defaultLocale: 'en', locales: ['en'], updatedAt: null };
+    let bundle = {
+        dictionaries: { en: {} },
+        defaultLocale: 'en',
+        locales: ['en'],
+        updatedAt: null,
+    };
     let command = 'build';
     let devServer = null;
     let eventSockets = [];
     let reconnectTimer;
     let refreshTimer;
     let pollTimer;
+    let eventConnectionAttempt = 0;
+    let closed = false;
     const refreshLabels = async () => {
         bundle = await loadLabelBundle(rootDir);
         return bundle;
@@ -51,13 +60,91 @@ export default function translationsPlugin() {
         });
     };
     const scheduleRefresh = () => {
+        if (closed) {
+            return;
+        }
         if (refreshTimer) {
             clearTimeout(refreshTimer);
         }
         refreshTimer = setTimeout(() => {
+            refreshTimer = undefined;
+            if (closed) {
+                return;
+            }
             void refreshLabelsAndInvalidateIfChanged().catch(() => undefined);
         }, 150);
     };
+    const startFallbackPolling = () => {
+        if (closed || pollTimer) {
+            return;
+        }
+        pollTimer = setInterval(() => {
+            void refreshLabelsAndInvalidateIfChanged().catch(() => undefined);
+        }, FALLBACK_POLL_INTERVAL_MS);
+    };
+    const stopFallbackPolling = () => {
+        if (!pollTimer) {
+            return;
+        }
+        clearInterval(pollTimer);
+        pollTimer = undefined;
+    };
+    const closeEventSockets = () => {
+        closeSockets(eventSockets.splice(0));
+    };
+    const scheduleReconnect = (delayMs = EVENT_RECONNECT_DELAY_MS) => {
+        startFallbackPolling();
+        if (closed || reconnectTimer) {
+            return;
+        }
+        reconnectTimer = setTimeout(() => {
+            reconnectTimer = undefined;
+            closeEventSockets();
+            void connectEvents();
+        }, delayMs);
+    };
+    const connectEvents = async () => {
+        if (closed) {
+            return;
+        }
+        const attempt = ++eventConnectionAttempt;
+        const sockets = [];
+        eventSockets = sockets;
+        try {
+            await connectLabelEvents(rootDir, scheduleRefresh, sockets, {
+                isActive: () => !closed && attempt === eventConnectionAttempt,
+                onConnected: () => {
+                    if (closed || attempt !== eventConnectionAttempt) {
+                        return;
+                    }
+                    if (reconnectTimer) {
+                        clearTimeout(reconnectTimer);
+                        reconnectTimer = undefined;
+                    }
+                    stopFallbackPolling();
+                },
+                onDisconnected: () => {
+                    if (closed || attempt !== eventConnectionAttempt) {
+                        return;
+                    }
+                    scheduleReconnect();
+                },
+            });
+            if (closed || attempt !== eventConnectionAttempt) {
+                closeSockets(sockets.splice(0));
+                return;
+            }
+            if (sockets.length === 0) {
+                scheduleReconnect(FALLBACK_POLL_INTERVAL_MS);
+            }
+        }
+        catch {
+            if (!closed && attempt === eventConnectionAttempt) {
+                closeEventSockets();
+                scheduleReconnect(FALLBACK_POLL_INTERVAL_MS);
+            }
+        }
+    };
     return {
         name: 'fimo-virtual-translations',
         enforce: 'pre',
@@ -76,16 +163,11 @@ export default function translationsPlugin() {
         },
         configureServer(server) {
             devServer = server;
+            closed = false;
             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);
+            startFallbackPolling();
+            void connectEvents();
         },
         resolveId(id) {
             if (id === VIRTUAL_ID) {
@@ -128,84 +210,119 @@ export default function translationsPlugin() {
             return [];
         },
         closeBundle() {
-            for (const socket of eventSockets) {
-                socket.close();
-            }
-            eventSockets = [];
+            closed = true;
+            eventConnectionAttempt += 1;
+            closeEventSockets();
+            devServer = null;
             if (reconnectTimer) {
                 clearTimeout(reconnectTimer);
+                reconnectTimer = undefined;
             }
             if (refreshTimer) {
                 clearTimeout(refreshTimer);
+                refreshTimer = undefined;
             }
-            if (pollTimer) {
-                clearInterval(pollTimer);
-            }
+            stopFallbackPolling();
         },
     };
-    async function connectLabelEvents(root, onLabelsChanged) {
+    async function connectLabelEvents(root, onLabelsChanged, sockets, callbacks) {
         const env = await readProjectEnv(root);
+        if (!callbacks.isActive()) {
+            return;
+        }
         const apiUrl = env.VITE_API_URL;
         if (!apiUrl) {
-            return [];
+            return;
         }
         const runtimeConfig = await loadRuntimeConfig(apiUrl);
+        if (!callbacks.isActive()) {
+            return;
+        }
         const eventsUrl = runtimeConfig.eventsServerUrl ?? undefined;
         if (!eventsUrl) {
-            return [];
+            return;
         }
         const settings = await readProjectSettings(root);
+        if (!callbacks.isActive()) {
+            return;
+        }
         if (!settings.projectId) {
-            return [];
+            return;
         }
         const WebSocketCtor = globalThis.WebSocket;
         if (!WebSocketCtor) {
-            return [];
+            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) {
+        const rooms = deriveEventsRooms(settings.projectId, apiUrl);
+        const openSockets = new Set();
+        try {
+            for (const room of rooms) {
+                const token = await generateOneTimeToken(settings.apiUrl ?? process.env.FIMO_API_URL ?? 'http://localhost:3000');
+                if (!callbacks.isActive()) {
+                    closeSockets(sockets.splice(0));
                     return;
                 }
-                try {
-                    const message = JSON.parse(raw);
-                    if (message.type === 'content:changed') {
-                        emitContentUpdate(parseContentChangePayload(message.payload));
+                const wsUrl = new URL(`/parties/events/${room}`, eventsUrl.replace(/^http/, 'ws'));
+                wsUrl.searchParams.set('authToken', token);
+                const socket = new WebSocketCtor(wsUrl.toString());
+                socket.onopen = () => {
+                    if (!callbacks.isActive()) {
                         return;
                     }
-                    if (message.type !== 'labels:changed') {
+                    openSockets.add(socket);
+                    if (openSockets.size === rooms.length) {
+                        callbacks.onConnected();
+                    }
+                };
+                socket.onmessage = (event) => {
+                    if (!callbacks.isActive()) {
                         return;
                     }
-                    const changedLocales = message.payload?.changes
-                        ?.map((change) => change.locale)
-                        .filter((locale) => typeof locale === 'string') ?? [];
-                    if (changedLocales.length === 0 || changedLocales.some((locale) => bundle.locales.includes(locale))) {
-                        onLabelsChanged();
+                    const raw = typeof event.data === 'string' ? event.data : '';
+                    if (!raw) {
+                        return;
                     }
-                }
-                catch {
-                    return;
-                }
-            };
-            socket.onclose = () => {
-                reconnectTimer = setTimeout(() => {
-                    void connectLabelEvents(root, onLabelsChanged)
-                        .then((nextSockets) => {
-                        eventSockets = nextSockets;
-                    })
-                        .catch(() => undefined);
-                }, 2000);
-            };
-            socket.onerror = () => undefined;
-            sockets.push(socket);
+                    try {
+                        const message = JSON.parse(raw);
+                        if (message.type === 'content:changed') {
+                            emitContentUpdate(parseContentChangePayload(message.payload));
+                            return;
+                        }
+                        if (message.type !== 'labels:changed') {
+                            return;
+                        }
+                        const changedLocales = message.payload?.changes
+                            ?.map((change) => change.locale)
+                            .filter((locale) => typeof locale === 'string') ?? [];
+                        if (changedLocales.length === 0 || changedLocales.some((locale) => bundle.locales.includes(locale))) {
+                            onLabelsChanged();
+                        }
+                    }
+                    catch {
+                        return;
+                    }
+                };
+                socket.onclose = () => {
+                    openSockets.delete(socket);
+                    callbacks.onDisconnected();
+                };
+                socket.onerror = callbacks.onDisconnected;
+                sockets.push(socket);
+            }
         }
-        return sockets;
+        catch (error) {
+            closeSockets(sockets.splice(0));
+            throw error;
+        }
+    }
+}
+function closeSockets(sockets) {
+    for (const socket of sockets) {
+        socket.onopen = null;
+        socket.onmessage = null;
+        socket.onclose = null;
+        socket.onerror = null;
+        socket.close();
     }
 }
 function parseContentChangePayload(payload) {

package/dist/cli/bundle.json

@@ -1,7 +1,7 @@
 {
   "bundled": true,
   "bundler": "esbuild",
-  "bundledAt": "2026-07-27T11:53:13.436Z",
+  "bundledAt": "2026-07-27T14:30:59.819Z",
   "cliVersion": "0.10.0",
   "external": [
     "oxc-parser",