rustuya-local 0.1.0.dev3__tar.gz → 0.1.0.dev5__tar.gz

{rustuya_local-0.1.0.dev3 → rustuya_local-0.1.0.dev5}/CHANGELOG.md

@@ -8,6 +8,25 @@ stable release.
 
 ## [Unreleased]
 
+## [0.1.0.dev5] — 2026-10-11
+
+### Fixed
+- Share the running service's complete bridge registry and MQTT command connection with the panel, so panel listing and edits do not open a second registry requester. Require complete contiguous registry pages for standalone setup sessions.
+- Keep explicit offline connection errors from being overwritten by replayed device state snapshots in the panel.
+
+### Changed
+- Split the HA panel synced filter into online and offline, with live sub-device/gateway state and migration of saved filters.
+- Check builtin rules when opening the HA panel; automatically install available updates when enabled, or enable the manual update button with a yellow dot when automatic updates are off.
+- Allow manual builtin rule updates while automatic updates are disabled.
+
+## [0.1.0.dev4] — 2026-10-11
+
+### Fixed
+- Fetch dev4 builtin rule updates from its development branch; master does not yet contain the new rules directory.
+
+### Changed
+- Label official rule updates as builtin rules in the HA panel and manager settings, and clarify that bundled rules remain available when online updates are off.
+
 ## [0.1.0.dev3] — 2026-10-11
 
 ### Changed

{rustuya_local-0.1.0.dev3 → rustuya_local-0.1.0.dev5}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: rustuya-local
-Version: 0.1.0.dev3
+Version: 0.1.0.dev5
 Summary: Local Tuya control: rustuya-bridge -> tuya2ildevice -> IL (ildevice). HA-independent core.
 Project-URL: Homepage, https://github.com/3735943886/rustuya-local
 Project-URL: Repository, https://github.com/3735943886/rustuya-local
@@ -66,7 +66,7 @@ source are cleared (other sources on the prefix are left alone), so IL consumers
 
 The shared Rust core interprets one device and has no MQTT or rule-file loading API.
 `rustuya_local.host.Hub` owns the device registry and maps `TuyaDriver` outputs to IL MQTT wire data;
-`host.rules` discovers and loads the bundled pack and user layers, passing decoded rules to Rust for composition.
+`host.rules` discovers and loads the bundled builtin rules and user layers, passing decoded rules to Rust for composition.
 The service preloads native code and rules in a worker thread before starting devices.
 Timers, retained-message policy, bridge `get` requests, presence and settings persistence remain in this host.
 MQTT and in-process transport tests exercise the same adapter and the bidirectional Rust driver.
@@ -102,12 +102,18 @@ config; integration: `<config>/rustuya_converters`; manager plugin: its data dir
   `{"overrides": {"product_id": {"cover": {"invert_position": true}}}}`.
 - Converters are JSON programs under `converters.declarative`; Python code plugins are not loaded.
 
-See tuya2ildevice's README ("User overrides") for the format. A curated set ships in tuya2ildevice, and fixes published
-between its releases (its [override pack](https://github.com/3735943886/tuya2ildevice/tree/master/rules/builtin)) are copied
-into `rules/builtin/` inside the overrides directory at start and daily. These include `00-default.json`; your own
-files are applied after all official rules. The bundled defaults update with tuya2ildevice, even when pack sync is off.
-Turn online updates off with `"pack": false` (daemon), the Rustuya panel's *Options* (integration), or the plugin tab. The pack only replaces or removes the files it
-put there, and leaves a file alone once you edit it.
+See tuya2ildevice's README ("User overrides") for the format. Official builtin rules, including `00-default.json`,
+ship with tuya2ildevice and update when that package is upgraded. They are applied before your own rule files.
+
+Online updates fetch the latest [builtin rules](https://github.com/3735943886/tuya2ildevice/tree/feat/rust-rule-engine/rules/builtin)
+into `rules/builtin/` inside the overrides directory at start and daily. In the Rustuya panel, use *Update builtin rules*
+to fetch them now or *Automatically update builtin rules* to control automatic updates. Opening the panel checks for
+updates: with automatic updates on, available changes are installed immediately without a yellow dot. With automatic
+updates off, available changes enable the manual update button with a yellow dot. The button is disabled while checking
+or when the installed rules are current. The daemon uses `"pack": false`
+to disable automatic updates; the manager plugin has the same option in its settings. Installed builtin rules remain
+available when automatic updates are off, and the panel still allows manual updates. Updates only replace or remove
+files they downloaded, preserving user edits.
 
 ### Cover settings
 
@@ -128,20 +134,23 @@ device settings are enabled, unless an override selects another source. A settin
 the setting is saved as the device's block in `zz_settings.json` in the converters directory and applied at once, so it
 survives a restart and can be edited there too. Without a converters directory (a daemon with no
 `custom_converters`) the switches are not offered; `"options": {"device_settings": false}` turns them off.
-A block with the same `cover` keys in your own file or the pack sets a model's starting point; the saved settings win.
+A block with the same `cover` keys in your own file or the builtin rules sets a model's starting point; the saved settings win.
 Older `cover.infer_motion` and `converters.cover_motion` blocks are upgraded on loading to `cover.state_source`
 (`inferred`, or `none` for `infer_motion: false`) and `cover.settle`; see [migration notes](docs/MIGRATING.md).
 
 In Home Assistant the files can be edited from a sidebar panel: the integration's *Configure* → *Add the Rustuya
 panel to the sidebar* adds it and links to it. The panel is for administrators. It fetches the device list from Tuya Cloud, shows the
-bridge's devices against the cloud list as rustuya-manager does (missing, bridge only, mismatch, synced, each a filter you can
+bridge's devices using the running service's complete registry and MQTT connection against the cloud list (missing, bridge only, mismatch, online and offline, each a filter you can
 turn off; sub-devices under their gateway; each device's bridge connection, live while the panel is open) with add /
-update / remove. *Register manually* adds Wi-Fi devices or sub-devices without a cloud login, using the same
+update / remove. Online and offline split devices whose cloud and bridge records match; selecting both shows the
+previous synced view. Sub-devices use their own link state, falling back to their gateway when unavailable; an offline
+gateway makes its sub-devices offline. Unknown state is grouped under offline. A gateway stays visible for context
+when one of its children matches the filters. *Register manually* adds Wi-Fi devices or sub-devices without a cloud login, using the same
 fields as rustuya-manager. Devices absent from the cloud list appear under *Bridge only*; their removal is not
-preselected in bulk sync. The panel lists the converter files with the pack's
-marked, edits and deletes them (drop JSON rule files on it to copy them in), runs the pack sync on demand, has the
+preselected in bulk sync. The panel lists, edits and deletes user converter files (drop JSON rule files on it to copy them in),
+updates builtin rules on demand, and has the
 *Options* (remote control of locks, alarms and garage doors; data points Home Assistant core would not classify; the
-override pack), and the *Settings* setup leaves at their defaults: the bridge topic root, the IL prefix and source, the device file, and
+automatic builtin rule updates), and the *Settings* setup leaves at their defaults: the bridge topic root, the IL prefix and source, the device file, and
 the embedded bridge's state file and log level. Saving restarts the integration; moving the IL prefix or source first
 clears what the old one left on the broker. *Hide panel* in its toolbar turns it off again. The integration and the panel follow Home Assistant's
 language: Korean, or English.
@@ -149,7 +158,7 @@ language: Korean, or English.
 ## rustuya-manager plugin
 
 Installed next to rustuya-manager, as a pip package (`pip install rustuya-local` in the manager's environment) or as
-the drop-in zip each release carries (`rustuya_local-<version>-dropin.zip`, tuya2ildevice binding, native library and rule pack vendored inside, built by
+the drop-in zip each release carries (`rustuya_local-<version>-dropin.zip`, tuya2ildevice binding, native library and builtin rules vendored inside, built by
 `scripts/build_dropin.py`; unpack it into the manager's plugin directory, or install it from the manager's plugin
 catalog once listed there), it appears as a **Tuya (IL)** tab and runs the service under the manager: the manager's broker and bridge root, the manager's device
 list (followed). Its data dir (`rustuya-local/` next to the manager's plugins) holds `settings.json` (`il`,

{rustuya_local-0.1.0.dev3 → rustuya_local-0.1.0.dev5}/README.md

@@ -40,7 +40,7 @@ source are cleared (other sources on the prefix are left alone), so IL consumers
 
 The shared Rust core interprets one device and has no MQTT or rule-file loading API.
 `rustuya_local.host.Hub` owns the device registry and maps `TuyaDriver` outputs to IL MQTT wire data;
-`host.rules` discovers and loads the bundled pack and user layers, passing decoded rules to Rust for composition.
+`host.rules` discovers and loads the bundled builtin rules and user layers, passing decoded rules to Rust for composition.
 The service preloads native code and rules in a worker thread before starting devices.
 Timers, retained-message policy, bridge `get` requests, presence and settings persistence remain in this host.
 MQTT and in-process transport tests exercise the same adapter and the bidirectional Rust driver.
@@ -76,12 +76,18 @@ config; integration: `<config>/rustuya_converters`; manager plugin: its data dir
   `{"overrides": {"product_id": {"cover": {"invert_position": true}}}}`.
 - Converters are JSON programs under `converters.declarative`; Python code plugins are not loaded.
 
-See tuya2ildevice's README ("User overrides") for the format. A curated set ships in tuya2ildevice, and fixes published
-between its releases (its [override pack](https://github.com/3735943886/tuya2ildevice/tree/master/rules/builtin)) are copied
-into `rules/builtin/` inside the overrides directory at start and daily. These include `00-default.json`; your own
-files are applied after all official rules. The bundled defaults update with tuya2ildevice, even when pack sync is off.
-Turn online updates off with `"pack": false` (daemon), the Rustuya panel's *Options* (integration), or the plugin tab. The pack only replaces or removes the files it
-put there, and leaves a file alone once you edit it.
+See tuya2ildevice's README ("User overrides") for the format. Official builtin rules, including `00-default.json`,
+ship with tuya2ildevice and update when that package is upgraded. They are applied before your own rule files.
+
+Online updates fetch the latest [builtin rules](https://github.com/3735943886/tuya2ildevice/tree/feat/rust-rule-engine/rules/builtin)
+into `rules/builtin/` inside the overrides directory at start and daily. In the Rustuya panel, use *Update builtin rules*
+to fetch them now or *Automatically update builtin rules* to control automatic updates. Opening the panel checks for
+updates: with automatic updates on, available changes are installed immediately without a yellow dot. With automatic
+updates off, available changes enable the manual update button with a yellow dot. The button is disabled while checking
+or when the installed rules are current. The daemon uses `"pack": false`
+to disable automatic updates; the manager plugin has the same option in its settings. Installed builtin rules remain
+available when automatic updates are off, and the panel still allows manual updates. Updates only replace or remove
+files they downloaded, preserving user edits.
 
 ### Cover settings
 
@@ -102,20 +108,23 @@ device settings are enabled, unless an override selects another source. A settin
 the setting is saved as the device's block in `zz_settings.json` in the converters directory and applied at once, so it
 survives a restart and can be edited there too. Without a converters directory (a daemon with no
 `custom_converters`) the switches are not offered; `"options": {"device_settings": false}` turns them off.
-A block with the same `cover` keys in your own file or the pack sets a model's starting point; the saved settings win.
+A block with the same `cover` keys in your own file or the builtin rules sets a model's starting point; the saved settings win.
 Older `cover.infer_motion` and `converters.cover_motion` blocks are upgraded on loading to `cover.state_source`
 (`inferred`, or `none` for `infer_motion: false`) and `cover.settle`; see [migration notes](docs/MIGRATING.md).
 
 In Home Assistant the files can be edited from a sidebar panel: the integration's *Configure* → *Add the Rustuya
 panel to the sidebar* adds it and links to it. The panel is for administrators. It fetches the device list from Tuya Cloud, shows the
-bridge's devices against the cloud list as rustuya-manager does (missing, bridge only, mismatch, synced, each a filter you can
+bridge's devices using the running service's complete registry and MQTT connection against the cloud list (missing, bridge only, mismatch, online and offline, each a filter you can
 turn off; sub-devices under their gateway; each device's bridge connection, live while the panel is open) with add /
-update / remove. *Register manually* adds Wi-Fi devices or sub-devices without a cloud login, using the same
+update / remove. Online and offline split devices whose cloud and bridge records match; selecting both shows the
+previous synced view. Sub-devices use their own link state, falling back to their gateway when unavailable; an offline
+gateway makes its sub-devices offline. Unknown state is grouped under offline. A gateway stays visible for context
+when one of its children matches the filters. *Register manually* adds Wi-Fi devices or sub-devices without a cloud login, using the same
 fields as rustuya-manager. Devices absent from the cloud list appear under *Bridge only*; their removal is not
-preselected in bulk sync. The panel lists the converter files with the pack's
-marked, edits and deletes them (drop JSON rule files on it to copy them in), runs the pack sync on demand, has the
+preselected in bulk sync. The panel lists, edits and deletes user converter files (drop JSON rule files on it to copy them in),
+updates builtin rules on demand, and has the
 *Options* (remote control of locks, alarms and garage doors; data points Home Assistant core would not classify; the
-override pack), and the *Settings* setup leaves at their defaults: the bridge topic root, the IL prefix and source, the device file, and
+automatic builtin rule updates), and the *Settings* setup leaves at their defaults: the bridge topic root, the IL prefix and source, the device file, and
 the embedded bridge's state file and log level. Saving restarts the integration; moving the IL prefix or source first
 clears what the old one left on the broker. *Hide panel* in its toolbar turns it off again. The integration and the panel follow Home Assistant's
 language: Korean, or English.
@@ -123,7 +132,7 @@ language: Korean, or English.
 ## rustuya-manager plugin
 
 Installed next to rustuya-manager, as a pip package (`pip install rustuya-local` in the manager's environment) or as
-the drop-in zip each release carries (`rustuya_local-<version>-dropin.zip`, tuya2ildevice binding, native library and rule pack vendored inside, built by
+the drop-in zip each release carries (`rustuya_local-<version>-dropin.zip`, tuya2ildevice binding, native library and builtin rules vendored inside, built by
 `scripts/build_dropin.py`; unpack it into the manager's plugin directory, or install it from the manager's plugin
 catalog once listed there), it appears as a **Tuya (IL)** tab and runs the service under the manager: the manager's broker and bridge root, the manager's device
 list (followed). Its data dir (`rustuya-local/` next to the manager's plugins) holds `settings.json` (`il`,

rustuya_local-0.1.0.dev5/custom_components/rustuya/manager_registry.py

@@ -0,0 +1,71 @@
+"""Per-session compatibility guard for manager versions accepting incomplete status pages.
+
+The response topic is broadcast: the service and a short-lived Manager can receive each other's
+pages. Only a contiguous snapshot starting at zero may become the panel/config flow's registry.
+"""
+from __future__ import annotations
+
+import asyncio
+import time
+from typing import Any
+
+
+async def ready_registry(manager: Any, timeout: float) -> None:
+    client = getattr(manager, "client", None)
+    if client is None or not hasattr(client, "_handle_status_page"):
+        await manager.wait_ready()
+        return
+
+    request = client._request_status
+    handle = client._handle_status_page
+    offset = 0
+    total = None
+    ids: set[str] = set()
+    complete = False
+
+    async def request_status() -> None:
+        nonlocal offset, total, complete
+        if (not client._status_active or client._status_started is None
+                or time.monotonic() - client._status_started >= client._STATUS_CYCLE_TIMEOUT):
+            offset, total, complete = 0, None, False
+            ids.clear()
+            client._status_accum = None
+        await request()
+
+    async def handle_page(parsed: dict[str, Any]) -> None:
+        nonlocal offset, total, complete
+        if not client._status_active:
+            return
+        devices = parsed.get("devices")
+        start = parsed.get("offset", 0)
+        returned = parsed.get("returned", len(devices) if isinstance(devices, dict) else 0)
+        count = parsed.get("device_count")
+        more = parsed.get("has_more", False)
+        if (not isinstance(devices, dict) or type(start) is not int or start != offset
+                or type(returned) is not int or returned != len(devices)
+                or type(more) is not bool or (more and not returned)
+                or ids.intersection(devices)):
+            return
+        if count is not None and (type(count) is not int or count < start + returned
+                                  or more != (start + returned < count)):
+            return
+        if offset and count != total:
+            return
+        total = count
+        offset += returned
+        ids.update(devices)
+        complete = not more
+        await handle(parsed)
+
+    client._request_status = request_status
+    client._handle_status_page = handle_page
+    await client.wait_bootstrap(timeout=timeout)
+    if not client._bootstrap_done.is_set():
+        raise TimeoutError("bridge subscriptions are not ready")
+    # Bootstrap may have received pages before the guard was installed. Start a fresh
+    # offset-zero cycle after subscription readiness instead of trusting that snapshot.
+    client._status_started = None
+    await client._request_status()
+    await asyncio.wait_for(client._status_idle.wait(), timeout)
+    if not complete:
+        raise TimeoutError("incomplete bridge registry")

{rustuya_local-0.1.0.dev3 → rustuya_local-0.1.0.dev5}/custom_components/rustuya/manager_session.py

@@ -68,7 +68,9 @@ async def open_manager(*, broker: str, root: str, devices_path: str, username: s
         # `sync()`'s diff is only meaningful once the bridge's device list has arrived; without this every cloud
         # device looks "missing" (an empty bridge side), which is how a whole device list ended up offered for
         # registration.
-        await manager.wait_ready()
+        from .manager_registry import ready_registry
+
+        await ready_registry(manager, WAIT)
     except BaseException:
         await close_manager(manager)
         raise
@@ -107,6 +109,26 @@ async def open_for_entry(hass: Any, data: dict[str, Any], *, run_bridge: bool =
                               devices_path=data[CONF_DEVICES_PATH], username=username, password=password, **bridge)
 
 
+async def open_panel_for_entry(hass: Any, data: dict[str, Any], service: Any):
+    """Share the loaded service's registry and command transport; no Manager MQTT connection."""
+    from .const import CONF_DEVICES_PATH
+    from .panel_bridge import PanelBridge
+
+    lock = _lock()
+    try:
+        await asyncio.wait_for(lock.acquire(), WAIT)
+    except TimeoutError as e:
+        raise Busy from e
+    session = PanelBridge(hass, service, data[CONF_DEVICES_PATH])
+    _HOLDERS[session] = lock
+    try:
+        await session.ready()
+    except BaseException:
+        await close_manager(session)
+        raise
+    return session
+
+
 async def saved_user_code(hass: Any, data: dict[str, Any]) -> str | None:
     """The user code of the saved Tuya login (`tuyacreds.json` beside the device file, where a session's wizard keeps
     it), read without a session: no broker connection and no lock, so the panel can fill it in before a fetch starts."""

{rustuya_local-0.1.0.dev3 → rustuya_local-0.1.0.dev5}/custom_components/rustuya/manifest.json

@@ -13,8 +13,8 @@
     "paho-mqtt>=2.0",
     "rustuya-manager>=0.2.2",
     "pyrustuyabridge>=0.4",
-    "rustuya-local>=0.1.0.dev3"
+    "rustuya-local>=0.1.0.dev5"
   ],
   "single_config_entry": true,
-  "version": "0.1.0.dev3"
+  "version": "0.1.0.dev5"
 }

{rustuya_local-0.1.0.dev3 → rustuya_local-0.1.0.dev5}/custom_components/rustuya/panel.py

@@ -349,11 +349,15 @@ async def _restart(hass: HomeAssistant, entry: Any, *, data: dict[str, Any] | No
 
 
 class PackView(_View):
-    """POST: sync the override pack now rather than at the end of its day; `pack` in the list shows the result."""
+    """GET checks for updates without writes; POST requests a sync."""
 
     url = "/api/rustuya/pack"
     name = "api:rustuya:pack"
 
+    @_entry_view
+    async def get(self, request: web.Request, entry: Any, runtime: Any) -> web.Response:
+        return self.json(await runtime.service.check_pack())
+
     @_entry_view
     async def post(self, request: web.Request, entry: Any, runtime: Any) -> web.Response:
         return self.json({"started": runtime.service.sync_pack_now()})
@@ -536,8 +540,8 @@ def _manual_device(body: Any) -> dict[str, str]:
 
 
 class BridgeView(_View):
-    """The cloud list against what the bridge holds, through a rustuya-manager session like the options flow's
-    `bridge_sync` step (and sharing its lock: one session at a time). GET: every device with its category. POST
+    """The cloud list against the running service's complete bridge registry, sharing the management session lock.
+    GET: every device with its category. POST
     `{"add": [...], "update": [...], "remove": [...]}`: those commands (only for ids the diff has in that category),
     then the list again. PATCH edits an existing device; PUT registers a manual device (id/name, WiFi key/ip/version or SubDevice cid/parent_id).
     `online` is the running service's link state by id."""
@@ -592,7 +596,7 @@ class BridgeView(_View):
         if not manager_session.available():
             return self.json_message("rustuya-manager is not installed", HTTPStatus.NOT_IMPLEMENTED)
         try:
-            manager = await manager_session.open_for_entry(request.app["hass"], entry.data)
+            manager = await manager_session.open_panel_for_entry(request.app["hass"], entry.data, runtime.service)
         except manager_session.Busy:
             return self.json_message("a Tuya login or device sync window is open; close it and try again",
                                      HTTPStatus.CONFLICT)

rustuya_local-0.1.0.dev5/custom_components/rustuya/panel_bridge.py

@@ -0,0 +1,48 @@
+"""Panel device management through the running service, without another MQTT registry requester."""
+from __future__ import annotations
+
+import json
+from pathlib import Path
+from types import SimpleNamespace
+from typing import Any
+
+
+class PanelBridge:
+    def __init__(self, hass: Any, service: Any, devices_path: str) -> None:
+        self.hass = hass
+        self.client = getattr(service, "bridge_client", None)
+        self.path = Path(devices_path)
+        self.state = SimpleNamespace(cloud={}, bridge={})
+
+    async def ready(self) -> None:
+        if self.client is None:
+            raise RuntimeError("Rustuya service is not ready")
+        await self.sync()
+
+    async def sync(self):
+        from rustuya_manager.diff import diff
+        from rustuya_manager.models import Device
+
+        def cloud():
+            if not self.path.exists():
+                return {}
+            data = json.loads(self.path.read_text("utf-8"))
+            records = data if isinstance(data, list) else data.values()
+            return {d["id"]: Device.from_dict(d) for d in records if "id" in d}
+
+        self.state.cloud = await self.hass.async_add_executor_job(cloud)
+        records = await self.client.registry()
+        self.state.bridge = {id: Device.from_dict({**record, "id": id}) for id, record in records.items()}
+        return diff(self.state.cloud, self.state.bridge)
+
+    async def publish_command(self, action: str, **kw) -> None:
+        await self.client.publish_command(action, **kw)
+
+    async def remove_device(self, target_id: str) -> None:
+        await self.publish_command("remove", target_id=target_id)
+
+    async def wait_registry_refresh(self) -> None:
+        await self.client.registry(refresh=True)
+
+    async def __aexit__(self, *exc) -> None:
+        pass

{rustuya_local-0.1.0.dev3 → rustuya_local-0.1.0.dev5}/custom_components/rustuya/strings.json

@@ -138,7 +138,7 @@
       "wizard_failed": "Fetching from Tuya Cloud failed: {error}",
       "no_devices": "There are no devices in the cloud list or on the bridge.",
       "manager_busy": "Another Tuya Cloud fetch or device sync window is still open. Close it and try again.",
-      "panel_shown": "The Rustuya panel was added to the sidebar: [open it]({url}). Its Options hold remote control of locks, alarms and garage doors, unused data points and the override pack.",
+      "panel_shown": "The Rustuya panel was added to the sidebar: [open it]({url}). Its Options hold remote control of locks, alarms and garage doors, unused data points and automatic builtin rule updates.",
       "panel_open": "[Open the Rustuya panel]({url})."
     },
     "error": {

{rustuya_local-0.1.0.dev3 → rustuya_local-0.1.0.dev5}/custom_components/rustuya/translations/en.json

@@ -138,7 +138,7 @@
       "wizard_failed": "Fetching from Tuya Cloud failed: {error}",
       "no_devices": "There are no devices in the cloud list or on the bridge.",
       "manager_busy": "Another Tuya Cloud fetch or device sync window is still open. Close it and try again.",
-      "panel_shown": "The Rustuya panel was added to the sidebar: [open it]({url}). Its Options hold remote control of locks, alarms and garage doors, unused data points and the override pack.",
+      "panel_shown": "The Rustuya panel was added to the sidebar: [open it]({url}). Its Options hold remote control of locks, alarms and garage doors, unused data points and automatic builtin rule updates.",
       "panel_open": "[Open the Rustuya panel]({url})."
     },
     "error": {

{rustuya_local-0.1.0.dev3 → rustuya_local-0.1.0.dev5}/custom_components/rustuya/translations/ko.json

@@ -138,7 +138,7 @@
       "wizard_failed": "Tuya Cloud에서 가져오지 못했습니다: {error}",
       "no_devices": "클라우드 목록에도 브리지에도 기기가 없습니다.",
       "manager_busy": "다른 Tuya Cloud 가져오기 또는 기기 동기화 창이 아직 열려 있습니다. 그 창을 닫고 다시 시도하세요.",
-      "panel_shown": "사이드바에 Rustuya 패널이 추가되었습니다: [열기]({url}). 패널의 Options에서 잠금장치·경보·차고문 원격 제어, 분류되지 않는 데이터 포인트, 오버라이드 팩을 설정합니다.",
+      "panel_shown": "사이드바에 Rustuya 패널이 추가되었습니다: [열기]({url}). 패널의 Options에서 잠금장치·경보·차고문 원격 제어, 분류되지 않는 데이터 포인트, Builtin 규칙 자동 업데이트를 설정합니다.",
       "panel_open": "[Rustuya 패널 열기]({url})"
     },
     "error": {